@bytecodealliance/jco 1.10.2 → 1.11.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 (52) hide show
  1. package/package.json +18 -6
  2. package/src/cmd/componentize.js +64 -18
  3. package/src/cmd/opt.js +233 -202
  4. package/src/cmd/run.js +117 -73
  5. package/src/cmd/transpile.js +643 -530
  6. package/src/cmd/wasm-tools.js +130 -95
  7. package/src/jco.js +5 -1
  8. package/obj/interfaces/local-wasm-tools-tools.d.ts +0 -52
  9. package/obj/interfaces/wasi-cli-environment.d.ts +0 -2
  10. package/obj/interfaces/wasi-cli-exit.d.ts +0 -3
  11. package/obj/interfaces/wasi-cli-stderr.d.ts +0 -3
  12. package/obj/interfaces/wasi-cli-stdin.d.ts +0 -3
  13. package/obj/interfaces/wasi-cli-stdout.d.ts +0 -3
  14. package/obj/interfaces/wasi-cli-terminal-input.d.ts +0 -8
  15. package/obj/interfaces/wasi-cli-terminal-output.d.ts +0 -8
  16. package/obj/interfaces/wasi-cli-terminal-stderr.d.ts +0 -3
  17. package/obj/interfaces/wasi-cli-terminal-stdin.d.ts +0 -3
  18. package/obj/interfaces/wasi-cli-terminal-stdout.d.ts +0 -3
  19. package/obj/interfaces/wasi-clocks-wall-clock.d.ts +0 -5
  20. package/obj/interfaces/wasi-filesystem-preopens.d.ts +0 -3
  21. package/obj/interfaces/wasi-filesystem-types.d.ts +0 -164
  22. package/obj/interfaces/wasi-io-error.d.ts +0 -8
  23. package/obj/interfaces/wasi-io-streams.d.ts +0 -30
  24. package/obj/interfaces/wasi-random-random.d.ts +0 -2
  25. package/obj/js-component-bindgen-component.core.wasm +0 -0
  26. package/obj/js-component-bindgen-component.core2.wasm +0 -0
  27. package/obj/js-component-bindgen-component.d.ts +0 -116
  28. package/obj/js-component-bindgen-component.js +0 -4302
  29. package/obj/wasm-tools.core.wasm +0 -0
  30. package/obj/wasm-tools.core2.wasm +0 -0
  31. package/obj/wasm-tools.d.ts +0 -20
  32. package/obj/wasm-tools.js +0 -4369
  33. package/src/api.d.ts +0 -42
  34. package/src/api.d.ts.map +0 -1
  35. package/src/browser.d.ts +0 -4
  36. package/src/browser.d.ts.map +0 -1
  37. package/src/cmd/componentize.d.ts +0 -2
  38. package/src/cmd/componentize.d.ts.map +0 -1
  39. package/src/cmd/opt.d.ts +0 -20
  40. package/src/cmd/opt.d.ts.map +0 -1
  41. package/src/cmd/run.d.ts +0 -3
  42. package/src/cmd/run.d.ts.map +0 -1
  43. package/src/cmd/transpile.d.ts +0 -89
  44. package/src/cmd/transpile.d.ts.map +0 -1
  45. package/src/cmd/wasm-tools.d.ts +0 -8
  46. package/src/cmd/wasm-tools.d.ts.map +0 -1
  47. package/src/common.d.ts +0 -16
  48. package/src/common.d.ts.map +0 -1
  49. package/src/jco.d.ts +0 -3
  50. package/src/jco.d.ts.map +0 -1
  51. package/src/ora-shim.d.ts +0 -7
  52. package/src/ora-shim.d.ts.map +0 -1
@@ -1,4302 +0,0 @@
1
- import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
2
- import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
3
- import { error, streams } from '@bytecodealliance/preview2-shim/io';
4
- import { random } from '@bytecodealliance/preview2-shim/random';
5
- const { getEnvironment } = environment;
6
- const { exit } = exit$1;
7
- const { getStderr } = stderr;
8
- const { getStdin } = stdin;
9
- const { getStdout } = stdout;
10
- const { TerminalInput } = terminalInput;
11
- const { TerminalOutput } = terminalOutput;
12
- const { getTerminalStderr } = terminalStderr;
13
- const { getTerminalStdin } = terminalStdin;
14
- const { getTerminalStdout } = terminalStdout;
15
- const { getDirectories } = preopens;
16
- const { Descriptor,
17
- DirectoryEntryStream,
18
- filesystemErrorCode } = types;
19
- const { Error: Error$1 } = error;
20
- const { InputStream,
21
- OutputStream } = streams;
22
- const { getRandomBytes } = random;
23
-
24
- const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
25
-
26
- class ComponentError extends Error {
27
- constructor (value) {
28
- const enumerable = typeof value !== 'string';
29
- super(enumerable ? `${String(value)} (see error.payload)` : value);
30
- Object.defineProperty(this, 'payload', { value, enumerable });
31
- }
32
- }
33
-
34
- let curResourceBorrows = [];
35
-
36
- let dv = new DataView(new ArrayBuffer());
37
- const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
38
-
39
- const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
40
- let _fs;
41
- async function fetchCompile (url) {
42
- if (isNode) {
43
- _fs = _fs || await import('node:fs/promises');
44
- return WebAssembly.compile(await _fs.readFile(url));
45
- }
46
- return fetch(url).then(WebAssembly.compileStreaming);
47
- }
48
-
49
- function getErrorPayload(e) {
50
- if (e && hasOwnProperty.call(e, 'payload')) return e.payload;
51
- if (e instanceof Error) throw e;
52
- return e;
53
- }
54
-
55
- const handleTables = [];
56
-
57
- const hasOwnProperty = Object.prototype.hasOwnProperty;
58
-
59
- const instantiateCore = WebAssembly.instantiate;
60
-
61
- const T_FLAG = 1 << 30;
62
-
63
- function rscTableCreateOwn (table, rep) {
64
- const free = table[0] & ~T_FLAG;
65
- if (free === 0) {
66
- table.push(0);
67
- table.push(rep | T_FLAG);
68
- return (table.length >> 1) - 1;
69
- }
70
- table[0] = table[free << 1];
71
- table[free << 1] = 0;
72
- table[(free << 1) + 1] = rep | T_FLAG;
73
- return free;
74
- }
75
-
76
- function rscTableRemove (table, handle) {
77
- const scope = table[handle << 1];
78
- const val = table[(handle << 1) + 1];
79
- const own = (val & T_FLAG) !== 0;
80
- const rep = val & ~T_FLAG;
81
- if (val === 0 || (scope & T_FLAG) !== 0) throw new TypeError('Invalid handle');
82
- table[handle << 1] = table[0] | T_FLAG;
83
- table[0] = handle | T_FLAG;
84
- return { rep, scope, own };
85
- }
86
-
87
- const symbolCabiDispose = Symbol.for('cabiDispose');
88
-
89
- const symbolRscHandle = Symbol('handle');
90
-
91
- const symbolRscRep = Symbol.for('cabiRep');
92
-
93
- const symbolDispose = Symbol.dispose || Symbol.for('dispose');
94
-
95
- function throwUninitialized() {
96
- throw new TypeError('Wasm uninitialized use `await $init` first');
97
- }
98
-
99
- const toUint64 = val => BigInt.asUintN(64, BigInt(val));
100
-
101
- function toUint32(val) {
102
- return val >>> 0;
103
- }
104
-
105
- const utf8Decoder = new TextDecoder();
106
-
107
- const utf8Encoder = new TextEncoder();
108
-
109
- let utf8EncodedLen = 0;
110
- function utf8Encode(s, realloc, memory) {
111
- if (typeof s !== 'string') throw new TypeError('expected a string');
112
- if (s.length === 0) {
113
- utf8EncodedLen = 0;
114
- return 1;
115
- }
116
- let buf = utf8Encoder.encode(s);
117
- let ptr = realloc(0, 0, 1, buf.length);
118
- new Uint8Array(memory.buffer).set(buf, ptr);
119
- utf8EncodedLen = buf.length;
120
- return ptr;
121
- }
122
-
123
-
124
- let exports0;
125
- let exports1;
126
- const handleTable2 = [T_FLAG, 0];
127
- const captureTable2= new Map();
128
- let captureCnt2 = 0;
129
- handleTables[2] = handleTable2;
130
-
131
- function trampoline5() {
132
- const ret = getStderr();
133
- if (!(ret instanceof OutputStream)) {
134
- throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
135
- }
136
- var handle0 = ret[symbolRscHandle];
137
- if (!handle0) {
138
- const rep = ret[symbolRscRep] || ++captureCnt2;
139
- captureTable2.set(rep, ret);
140
- handle0 = rscTableCreateOwn(handleTable2, rep);
141
- }
142
- return handle0;
143
- }
144
-
145
- const handleTable1 = [T_FLAG, 0];
146
- const captureTable1= new Map();
147
- let captureCnt1 = 0;
148
- handleTables[1] = handleTable1;
149
-
150
- function trampoline8() {
151
- const ret = getStdin();
152
- if (!(ret instanceof InputStream)) {
153
- throw new TypeError('Resource error: Not a valid "InputStream" resource.');
154
- }
155
- var handle0 = ret[symbolRscHandle];
156
- if (!handle0) {
157
- const rep = ret[symbolRscRep] || ++captureCnt1;
158
- captureTable1.set(rep, ret);
159
- handle0 = rscTableCreateOwn(handleTable1, rep);
160
- }
161
- return handle0;
162
- }
163
-
164
-
165
- function trampoline9() {
166
- const ret = getStdout();
167
- if (!(ret instanceof OutputStream)) {
168
- throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
169
- }
170
- var handle0 = ret[symbolRscHandle];
171
- if (!handle0) {
172
- const rep = ret[symbolRscRep] || ++captureCnt2;
173
- captureTable2.set(rep, ret);
174
- handle0 = rscTableCreateOwn(handleTable2, rep);
175
- }
176
- return handle0;
177
- }
178
-
179
-
180
- function trampoline10(arg0) {
181
- let variant0;
182
- switch (arg0) {
183
- case 0: {
184
- variant0= {
185
- tag: 'ok',
186
- val: undefined
187
- };
188
- break;
189
- }
190
- case 1: {
191
- variant0= {
192
- tag: 'err',
193
- val: undefined
194
- };
195
- break;
196
- }
197
- default: {
198
- throw new TypeError('invalid variant discriminant for expected');
199
- }
200
- }
201
- exit(variant0);
202
- }
203
-
204
- let exports2;
205
- let memory0;
206
- let realloc0;
207
-
208
- function trampoline11(arg0) {
209
- const ret = getEnvironment();
210
- var vec3 = ret;
211
- var len3 = vec3.length;
212
- var result3 = realloc0(0, 0, 4, len3 * 16);
213
- for (let i = 0; i < vec3.length; i++) {
214
- const e = vec3[i];
215
- const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
216
- var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
217
- var len1 = utf8EncodedLen;
218
- dataView(memory0).setInt32(base + 4, len1, true);
219
- dataView(memory0).setInt32(base + 0, ptr1, true);
220
- var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
221
- var len2 = utf8EncodedLen;
222
- dataView(memory0).setInt32(base + 12, len2, true);
223
- dataView(memory0).setInt32(base + 8, ptr2, true);
224
- }
225
- dataView(memory0).setInt32(arg0 + 4, len3, true);
226
- dataView(memory0).setInt32(arg0 + 0, result3, true);
227
- }
228
-
229
- const handleTable5 = [T_FLAG, 0];
230
- const captureTable5= new Map();
231
- let captureCnt5 = 0;
232
- handleTables[5] = handleTable5;
233
-
234
- function trampoline12(arg0, arg1) {
235
- var handle1 = arg0;
236
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
237
- var rsc0 = captureTable5.get(rep2);
238
- if (!rsc0) {
239
- rsc0 = Object.create(Descriptor.prototype);
240
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
241
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
242
- }
243
- curResourceBorrows.push(rsc0);
244
- let ret;
245
- try {
246
- ret = { tag: 'ok', val: rsc0.getType()};
247
- } catch (e) {
248
- ret = { tag: 'err', val: getErrorPayload(e) };
249
- }
250
- for (const rsc of curResourceBorrows) {
251
- rsc[symbolRscHandle] = undefined;
252
- }
253
- curResourceBorrows = [];
254
- var variant5 = ret;
255
- switch (variant5.tag) {
256
- case 'ok': {
257
- const e = variant5.val;
258
- dataView(memory0).setInt8(arg1 + 0, 0, true);
259
- var val3 = e;
260
- let enum3;
261
- switch (val3) {
262
- case 'unknown': {
263
- enum3 = 0;
264
- break;
265
- }
266
- case 'block-device': {
267
- enum3 = 1;
268
- break;
269
- }
270
- case 'character-device': {
271
- enum3 = 2;
272
- break;
273
- }
274
- case 'directory': {
275
- enum3 = 3;
276
- break;
277
- }
278
- case 'fifo': {
279
- enum3 = 4;
280
- break;
281
- }
282
- case 'symbolic-link': {
283
- enum3 = 5;
284
- break;
285
- }
286
- case 'regular-file': {
287
- enum3 = 6;
288
- break;
289
- }
290
- case 'socket': {
291
- enum3 = 7;
292
- break;
293
- }
294
- default: {
295
- if ((e) instanceof Error) {
296
- console.error(e);
297
- }
298
-
299
- throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
300
- }
301
- }
302
- dataView(memory0).setInt8(arg1 + 1, enum3, true);
303
- break;
304
- }
305
- case 'err': {
306
- const e = variant5.val;
307
- dataView(memory0).setInt8(arg1 + 0, 1, true);
308
- var val4 = e;
309
- let enum4;
310
- switch (val4) {
311
- case 'access': {
312
- enum4 = 0;
313
- break;
314
- }
315
- case 'would-block': {
316
- enum4 = 1;
317
- break;
318
- }
319
- case 'already': {
320
- enum4 = 2;
321
- break;
322
- }
323
- case 'bad-descriptor': {
324
- enum4 = 3;
325
- break;
326
- }
327
- case 'busy': {
328
- enum4 = 4;
329
- break;
330
- }
331
- case 'deadlock': {
332
- enum4 = 5;
333
- break;
334
- }
335
- case 'quota': {
336
- enum4 = 6;
337
- break;
338
- }
339
- case 'exist': {
340
- enum4 = 7;
341
- break;
342
- }
343
- case 'file-too-large': {
344
- enum4 = 8;
345
- break;
346
- }
347
- case 'illegal-byte-sequence': {
348
- enum4 = 9;
349
- break;
350
- }
351
- case 'in-progress': {
352
- enum4 = 10;
353
- break;
354
- }
355
- case 'interrupted': {
356
- enum4 = 11;
357
- break;
358
- }
359
- case 'invalid': {
360
- enum4 = 12;
361
- break;
362
- }
363
- case 'io': {
364
- enum4 = 13;
365
- break;
366
- }
367
- case 'is-directory': {
368
- enum4 = 14;
369
- break;
370
- }
371
- case 'loop': {
372
- enum4 = 15;
373
- break;
374
- }
375
- case 'too-many-links': {
376
- enum4 = 16;
377
- break;
378
- }
379
- case 'message-size': {
380
- enum4 = 17;
381
- break;
382
- }
383
- case 'name-too-long': {
384
- enum4 = 18;
385
- break;
386
- }
387
- case 'no-device': {
388
- enum4 = 19;
389
- break;
390
- }
391
- case 'no-entry': {
392
- enum4 = 20;
393
- break;
394
- }
395
- case 'no-lock': {
396
- enum4 = 21;
397
- break;
398
- }
399
- case 'insufficient-memory': {
400
- enum4 = 22;
401
- break;
402
- }
403
- case 'insufficient-space': {
404
- enum4 = 23;
405
- break;
406
- }
407
- case 'not-directory': {
408
- enum4 = 24;
409
- break;
410
- }
411
- case 'not-empty': {
412
- enum4 = 25;
413
- break;
414
- }
415
- case 'not-recoverable': {
416
- enum4 = 26;
417
- break;
418
- }
419
- case 'unsupported': {
420
- enum4 = 27;
421
- break;
422
- }
423
- case 'no-tty': {
424
- enum4 = 28;
425
- break;
426
- }
427
- case 'no-such-device': {
428
- enum4 = 29;
429
- break;
430
- }
431
- case 'overflow': {
432
- enum4 = 30;
433
- break;
434
- }
435
- case 'not-permitted': {
436
- enum4 = 31;
437
- break;
438
- }
439
- case 'pipe': {
440
- enum4 = 32;
441
- break;
442
- }
443
- case 'read-only': {
444
- enum4 = 33;
445
- break;
446
- }
447
- case 'invalid-seek': {
448
- enum4 = 34;
449
- break;
450
- }
451
- case 'text-file-busy': {
452
- enum4 = 35;
453
- break;
454
- }
455
- case 'cross-device': {
456
- enum4 = 36;
457
- break;
458
- }
459
- default: {
460
- if ((e) instanceof Error) {
461
- console.error(e);
462
- }
463
-
464
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
465
- }
466
- }
467
- dataView(memory0).setInt8(arg1 + 1, enum4, true);
468
- break;
469
- }
470
- default: {
471
- throw new TypeError('invalid variant specified for result');
472
- }
473
- }
474
- }
475
-
476
-
477
- function trampoline13(arg0, arg1) {
478
- var handle1 = arg0;
479
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
480
- var rsc0 = captureTable5.get(rep2);
481
- if (!rsc0) {
482
- rsc0 = Object.create(Descriptor.prototype);
483
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
484
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
485
- }
486
- curResourceBorrows.push(rsc0);
487
- let ret;
488
- try {
489
- ret = { tag: 'ok', val: rsc0.metadataHash()};
490
- } catch (e) {
491
- ret = { tag: 'err', val: getErrorPayload(e) };
492
- }
493
- for (const rsc of curResourceBorrows) {
494
- rsc[symbolRscHandle] = undefined;
495
- }
496
- curResourceBorrows = [];
497
- var variant5 = ret;
498
- switch (variant5.tag) {
499
- case 'ok': {
500
- const e = variant5.val;
501
- dataView(memory0).setInt8(arg1 + 0, 0, true);
502
- var {lower: v3_0, upper: v3_1 } = e;
503
- dataView(memory0).setBigInt64(arg1 + 8, toUint64(v3_0), true);
504
- dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
505
- break;
506
- }
507
- case 'err': {
508
- const e = variant5.val;
509
- dataView(memory0).setInt8(arg1 + 0, 1, true);
510
- var val4 = e;
511
- let enum4;
512
- switch (val4) {
513
- case 'access': {
514
- enum4 = 0;
515
- break;
516
- }
517
- case 'would-block': {
518
- enum4 = 1;
519
- break;
520
- }
521
- case 'already': {
522
- enum4 = 2;
523
- break;
524
- }
525
- case 'bad-descriptor': {
526
- enum4 = 3;
527
- break;
528
- }
529
- case 'busy': {
530
- enum4 = 4;
531
- break;
532
- }
533
- case 'deadlock': {
534
- enum4 = 5;
535
- break;
536
- }
537
- case 'quota': {
538
- enum4 = 6;
539
- break;
540
- }
541
- case 'exist': {
542
- enum4 = 7;
543
- break;
544
- }
545
- case 'file-too-large': {
546
- enum4 = 8;
547
- break;
548
- }
549
- case 'illegal-byte-sequence': {
550
- enum4 = 9;
551
- break;
552
- }
553
- case 'in-progress': {
554
- enum4 = 10;
555
- break;
556
- }
557
- case 'interrupted': {
558
- enum4 = 11;
559
- break;
560
- }
561
- case 'invalid': {
562
- enum4 = 12;
563
- break;
564
- }
565
- case 'io': {
566
- enum4 = 13;
567
- break;
568
- }
569
- case 'is-directory': {
570
- enum4 = 14;
571
- break;
572
- }
573
- case 'loop': {
574
- enum4 = 15;
575
- break;
576
- }
577
- case 'too-many-links': {
578
- enum4 = 16;
579
- break;
580
- }
581
- case 'message-size': {
582
- enum4 = 17;
583
- break;
584
- }
585
- case 'name-too-long': {
586
- enum4 = 18;
587
- break;
588
- }
589
- case 'no-device': {
590
- enum4 = 19;
591
- break;
592
- }
593
- case 'no-entry': {
594
- enum4 = 20;
595
- break;
596
- }
597
- case 'no-lock': {
598
- enum4 = 21;
599
- break;
600
- }
601
- case 'insufficient-memory': {
602
- enum4 = 22;
603
- break;
604
- }
605
- case 'insufficient-space': {
606
- enum4 = 23;
607
- break;
608
- }
609
- case 'not-directory': {
610
- enum4 = 24;
611
- break;
612
- }
613
- case 'not-empty': {
614
- enum4 = 25;
615
- break;
616
- }
617
- case 'not-recoverable': {
618
- enum4 = 26;
619
- break;
620
- }
621
- case 'unsupported': {
622
- enum4 = 27;
623
- break;
624
- }
625
- case 'no-tty': {
626
- enum4 = 28;
627
- break;
628
- }
629
- case 'no-such-device': {
630
- enum4 = 29;
631
- break;
632
- }
633
- case 'overflow': {
634
- enum4 = 30;
635
- break;
636
- }
637
- case 'not-permitted': {
638
- enum4 = 31;
639
- break;
640
- }
641
- case 'pipe': {
642
- enum4 = 32;
643
- break;
644
- }
645
- case 'read-only': {
646
- enum4 = 33;
647
- break;
648
- }
649
- case 'invalid-seek': {
650
- enum4 = 34;
651
- break;
652
- }
653
- case 'text-file-busy': {
654
- enum4 = 35;
655
- break;
656
- }
657
- case 'cross-device': {
658
- enum4 = 36;
659
- break;
660
- }
661
- default: {
662
- if ((e) instanceof Error) {
663
- console.error(e);
664
- }
665
-
666
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
667
- }
668
- }
669
- dataView(memory0).setInt8(arg1 + 8, enum4, true);
670
- break;
671
- }
672
- default: {
673
- throw new TypeError('invalid variant specified for result');
674
- }
675
- }
676
- }
677
-
678
- const handleTable0 = [T_FLAG, 0];
679
- const captureTable0= new Map();
680
- let captureCnt0 = 0;
681
- handleTables[0] = handleTable0;
682
-
683
- function trampoline14(arg0, arg1) {
684
- var handle1 = arg0;
685
- var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
686
- var rsc0 = captureTable0.get(rep2);
687
- if (!rsc0) {
688
- rsc0 = Object.create(Error$1.prototype);
689
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
690
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
691
- }
692
- curResourceBorrows.push(rsc0);
693
- const ret = filesystemErrorCode(rsc0);
694
- for (const rsc of curResourceBorrows) {
695
- rsc[symbolRscHandle] = undefined;
696
- }
697
- curResourceBorrows = [];
698
- var variant4 = ret;
699
- if (variant4 === null || variant4=== undefined) {
700
- dataView(memory0).setInt8(arg1 + 0, 0, true);
701
- } else {
702
- const e = variant4;
703
- dataView(memory0).setInt8(arg1 + 0, 1, true);
704
- var val3 = e;
705
- let enum3;
706
- switch (val3) {
707
- case 'access': {
708
- enum3 = 0;
709
- break;
710
- }
711
- case 'would-block': {
712
- enum3 = 1;
713
- break;
714
- }
715
- case 'already': {
716
- enum3 = 2;
717
- break;
718
- }
719
- case 'bad-descriptor': {
720
- enum3 = 3;
721
- break;
722
- }
723
- case 'busy': {
724
- enum3 = 4;
725
- break;
726
- }
727
- case 'deadlock': {
728
- enum3 = 5;
729
- break;
730
- }
731
- case 'quota': {
732
- enum3 = 6;
733
- break;
734
- }
735
- case 'exist': {
736
- enum3 = 7;
737
- break;
738
- }
739
- case 'file-too-large': {
740
- enum3 = 8;
741
- break;
742
- }
743
- case 'illegal-byte-sequence': {
744
- enum3 = 9;
745
- break;
746
- }
747
- case 'in-progress': {
748
- enum3 = 10;
749
- break;
750
- }
751
- case 'interrupted': {
752
- enum3 = 11;
753
- break;
754
- }
755
- case 'invalid': {
756
- enum3 = 12;
757
- break;
758
- }
759
- case 'io': {
760
- enum3 = 13;
761
- break;
762
- }
763
- case 'is-directory': {
764
- enum3 = 14;
765
- break;
766
- }
767
- case 'loop': {
768
- enum3 = 15;
769
- break;
770
- }
771
- case 'too-many-links': {
772
- enum3 = 16;
773
- break;
774
- }
775
- case 'message-size': {
776
- enum3 = 17;
777
- break;
778
- }
779
- case 'name-too-long': {
780
- enum3 = 18;
781
- break;
782
- }
783
- case 'no-device': {
784
- enum3 = 19;
785
- break;
786
- }
787
- case 'no-entry': {
788
- enum3 = 20;
789
- break;
790
- }
791
- case 'no-lock': {
792
- enum3 = 21;
793
- break;
794
- }
795
- case 'insufficient-memory': {
796
- enum3 = 22;
797
- break;
798
- }
799
- case 'insufficient-space': {
800
- enum3 = 23;
801
- break;
802
- }
803
- case 'not-directory': {
804
- enum3 = 24;
805
- break;
806
- }
807
- case 'not-empty': {
808
- enum3 = 25;
809
- break;
810
- }
811
- case 'not-recoverable': {
812
- enum3 = 26;
813
- break;
814
- }
815
- case 'unsupported': {
816
- enum3 = 27;
817
- break;
818
- }
819
- case 'no-tty': {
820
- enum3 = 28;
821
- break;
822
- }
823
- case 'no-such-device': {
824
- enum3 = 29;
825
- break;
826
- }
827
- case 'overflow': {
828
- enum3 = 30;
829
- break;
830
- }
831
- case 'not-permitted': {
832
- enum3 = 31;
833
- break;
834
- }
835
- case 'pipe': {
836
- enum3 = 32;
837
- break;
838
- }
839
- case 'read-only': {
840
- enum3 = 33;
841
- break;
842
- }
843
- case 'invalid-seek': {
844
- enum3 = 34;
845
- break;
846
- }
847
- case 'text-file-busy': {
848
- enum3 = 35;
849
- break;
850
- }
851
- case 'cross-device': {
852
- enum3 = 36;
853
- break;
854
- }
855
- default: {
856
- if ((e) instanceof Error) {
857
- console.error(e);
858
- }
859
-
860
- throw new TypeError(`"${val3}" is not one of the cases of error-code`);
861
- }
862
- }
863
- dataView(memory0).setInt8(arg1 + 1, enum3, true);
864
- }
865
- }
866
-
867
-
868
- function trampoline15(arg0, arg1, arg2, arg3, arg4) {
869
- var handle1 = arg0;
870
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
871
- var rsc0 = captureTable5.get(rep2);
872
- if (!rsc0) {
873
- rsc0 = Object.create(Descriptor.prototype);
874
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
875
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
876
- }
877
- curResourceBorrows.push(rsc0);
878
- if ((arg1 & 4294967294) !== 0) {
879
- throw new TypeError('flags have extraneous bits set');
880
- }
881
- var flags3 = {
882
- symlinkFollow: Boolean(arg1 & 1),
883
- };
884
- var ptr4 = arg2;
885
- var len4 = arg3;
886
- var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
887
- let ret;
888
- try {
889
- ret = { tag: 'ok', val: rsc0.metadataHashAt(flags3, result4)};
890
- } catch (e) {
891
- ret = { tag: 'err', val: getErrorPayload(e) };
892
- }
893
- for (const rsc of curResourceBorrows) {
894
- rsc[symbolRscHandle] = undefined;
895
- }
896
- curResourceBorrows = [];
897
- var variant7 = ret;
898
- switch (variant7.tag) {
899
- case 'ok': {
900
- const e = variant7.val;
901
- dataView(memory0).setInt8(arg4 + 0, 0, true);
902
- var {lower: v5_0, upper: v5_1 } = e;
903
- dataView(memory0).setBigInt64(arg4 + 8, toUint64(v5_0), true);
904
- dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
905
- break;
906
- }
907
- case 'err': {
908
- const e = variant7.val;
909
- dataView(memory0).setInt8(arg4 + 0, 1, true);
910
- var val6 = e;
911
- let enum6;
912
- switch (val6) {
913
- case 'access': {
914
- enum6 = 0;
915
- break;
916
- }
917
- case 'would-block': {
918
- enum6 = 1;
919
- break;
920
- }
921
- case 'already': {
922
- enum6 = 2;
923
- break;
924
- }
925
- case 'bad-descriptor': {
926
- enum6 = 3;
927
- break;
928
- }
929
- case 'busy': {
930
- enum6 = 4;
931
- break;
932
- }
933
- case 'deadlock': {
934
- enum6 = 5;
935
- break;
936
- }
937
- case 'quota': {
938
- enum6 = 6;
939
- break;
940
- }
941
- case 'exist': {
942
- enum6 = 7;
943
- break;
944
- }
945
- case 'file-too-large': {
946
- enum6 = 8;
947
- break;
948
- }
949
- case 'illegal-byte-sequence': {
950
- enum6 = 9;
951
- break;
952
- }
953
- case 'in-progress': {
954
- enum6 = 10;
955
- break;
956
- }
957
- case 'interrupted': {
958
- enum6 = 11;
959
- break;
960
- }
961
- case 'invalid': {
962
- enum6 = 12;
963
- break;
964
- }
965
- case 'io': {
966
- enum6 = 13;
967
- break;
968
- }
969
- case 'is-directory': {
970
- enum6 = 14;
971
- break;
972
- }
973
- case 'loop': {
974
- enum6 = 15;
975
- break;
976
- }
977
- case 'too-many-links': {
978
- enum6 = 16;
979
- break;
980
- }
981
- case 'message-size': {
982
- enum6 = 17;
983
- break;
984
- }
985
- case 'name-too-long': {
986
- enum6 = 18;
987
- break;
988
- }
989
- case 'no-device': {
990
- enum6 = 19;
991
- break;
992
- }
993
- case 'no-entry': {
994
- enum6 = 20;
995
- break;
996
- }
997
- case 'no-lock': {
998
- enum6 = 21;
999
- break;
1000
- }
1001
- case 'insufficient-memory': {
1002
- enum6 = 22;
1003
- break;
1004
- }
1005
- case 'insufficient-space': {
1006
- enum6 = 23;
1007
- break;
1008
- }
1009
- case 'not-directory': {
1010
- enum6 = 24;
1011
- break;
1012
- }
1013
- case 'not-empty': {
1014
- enum6 = 25;
1015
- break;
1016
- }
1017
- case 'not-recoverable': {
1018
- enum6 = 26;
1019
- break;
1020
- }
1021
- case 'unsupported': {
1022
- enum6 = 27;
1023
- break;
1024
- }
1025
- case 'no-tty': {
1026
- enum6 = 28;
1027
- break;
1028
- }
1029
- case 'no-such-device': {
1030
- enum6 = 29;
1031
- break;
1032
- }
1033
- case 'overflow': {
1034
- enum6 = 30;
1035
- break;
1036
- }
1037
- case 'not-permitted': {
1038
- enum6 = 31;
1039
- break;
1040
- }
1041
- case 'pipe': {
1042
- enum6 = 32;
1043
- break;
1044
- }
1045
- case 'read-only': {
1046
- enum6 = 33;
1047
- break;
1048
- }
1049
- case 'invalid-seek': {
1050
- enum6 = 34;
1051
- break;
1052
- }
1053
- case 'text-file-busy': {
1054
- enum6 = 35;
1055
- break;
1056
- }
1057
- case 'cross-device': {
1058
- enum6 = 36;
1059
- break;
1060
- }
1061
- default: {
1062
- if ((e) instanceof Error) {
1063
- console.error(e);
1064
- }
1065
-
1066
- throw new TypeError(`"${val6}" is not one of the cases of error-code`);
1067
- }
1068
- }
1069
- dataView(memory0).setInt8(arg4 + 8, enum6, true);
1070
- break;
1071
- }
1072
- default: {
1073
- throw new TypeError('invalid variant specified for result');
1074
- }
1075
- }
1076
- }
1077
-
1078
-
1079
- function trampoline16(arg0, arg1, arg2) {
1080
- var handle1 = arg0;
1081
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1082
- var rsc0 = captureTable5.get(rep2);
1083
- if (!rsc0) {
1084
- rsc0 = Object.create(Descriptor.prototype);
1085
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
1086
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1087
- }
1088
- curResourceBorrows.push(rsc0);
1089
- let ret;
1090
- try {
1091
- ret = { tag: 'ok', val: rsc0.readViaStream(BigInt.asUintN(64, arg1))};
1092
- } catch (e) {
1093
- ret = { tag: 'err', val: getErrorPayload(e) };
1094
- }
1095
- for (const rsc of curResourceBorrows) {
1096
- rsc[symbolRscHandle] = undefined;
1097
- }
1098
- curResourceBorrows = [];
1099
- var variant5 = ret;
1100
- switch (variant5.tag) {
1101
- case 'ok': {
1102
- const e = variant5.val;
1103
- dataView(memory0).setInt8(arg2 + 0, 0, true);
1104
- if (!(e instanceof InputStream)) {
1105
- throw new TypeError('Resource error: Not a valid "InputStream" resource.');
1106
- }
1107
- var handle3 = e[symbolRscHandle];
1108
- if (!handle3) {
1109
- const rep = e[symbolRscRep] || ++captureCnt1;
1110
- captureTable1.set(rep, e);
1111
- handle3 = rscTableCreateOwn(handleTable1, rep);
1112
- }
1113
- dataView(memory0).setInt32(arg2 + 4, handle3, true);
1114
- break;
1115
- }
1116
- case 'err': {
1117
- const e = variant5.val;
1118
- dataView(memory0).setInt8(arg2 + 0, 1, true);
1119
- var val4 = e;
1120
- let enum4;
1121
- switch (val4) {
1122
- case 'access': {
1123
- enum4 = 0;
1124
- break;
1125
- }
1126
- case 'would-block': {
1127
- enum4 = 1;
1128
- break;
1129
- }
1130
- case 'already': {
1131
- enum4 = 2;
1132
- break;
1133
- }
1134
- case 'bad-descriptor': {
1135
- enum4 = 3;
1136
- break;
1137
- }
1138
- case 'busy': {
1139
- enum4 = 4;
1140
- break;
1141
- }
1142
- case 'deadlock': {
1143
- enum4 = 5;
1144
- break;
1145
- }
1146
- case 'quota': {
1147
- enum4 = 6;
1148
- break;
1149
- }
1150
- case 'exist': {
1151
- enum4 = 7;
1152
- break;
1153
- }
1154
- case 'file-too-large': {
1155
- enum4 = 8;
1156
- break;
1157
- }
1158
- case 'illegal-byte-sequence': {
1159
- enum4 = 9;
1160
- break;
1161
- }
1162
- case 'in-progress': {
1163
- enum4 = 10;
1164
- break;
1165
- }
1166
- case 'interrupted': {
1167
- enum4 = 11;
1168
- break;
1169
- }
1170
- case 'invalid': {
1171
- enum4 = 12;
1172
- break;
1173
- }
1174
- case 'io': {
1175
- enum4 = 13;
1176
- break;
1177
- }
1178
- case 'is-directory': {
1179
- enum4 = 14;
1180
- break;
1181
- }
1182
- case 'loop': {
1183
- enum4 = 15;
1184
- break;
1185
- }
1186
- case 'too-many-links': {
1187
- enum4 = 16;
1188
- break;
1189
- }
1190
- case 'message-size': {
1191
- enum4 = 17;
1192
- break;
1193
- }
1194
- case 'name-too-long': {
1195
- enum4 = 18;
1196
- break;
1197
- }
1198
- case 'no-device': {
1199
- enum4 = 19;
1200
- break;
1201
- }
1202
- case 'no-entry': {
1203
- enum4 = 20;
1204
- break;
1205
- }
1206
- case 'no-lock': {
1207
- enum4 = 21;
1208
- break;
1209
- }
1210
- case 'insufficient-memory': {
1211
- enum4 = 22;
1212
- break;
1213
- }
1214
- case 'insufficient-space': {
1215
- enum4 = 23;
1216
- break;
1217
- }
1218
- case 'not-directory': {
1219
- enum4 = 24;
1220
- break;
1221
- }
1222
- case 'not-empty': {
1223
- enum4 = 25;
1224
- break;
1225
- }
1226
- case 'not-recoverable': {
1227
- enum4 = 26;
1228
- break;
1229
- }
1230
- case 'unsupported': {
1231
- enum4 = 27;
1232
- break;
1233
- }
1234
- case 'no-tty': {
1235
- enum4 = 28;
1236
- break;
1237
- }
1238
- case 'no-such-device': {
1239
- enum4 = 29;
1240
- break;
1241
- }
1242
- case 'overflow': {
1243
- enum4 = 30;
1244
- break;
1245
- }
1246
- case 'not-permitted': {
1247
- enum4 = 31;
1248
- break;
1249
- }
1250
- case 'pipe': {
1251
- enum4 = 32;
1252
- break;
1253
- }
1254
- case 'read-only': {
1255
- enum4 = 33;
1256
- break;
1257
- }
1258
- case 'invalid-seek': {
1259
- enum4 = 34;
1260
- break;
1261
- }
1262
- case 'text-file-busy': {
1263
- enum4 = 35;
1264
- break;
1265
- }
1266
- case 'cross-device': {
1267
- enum4 = 36;
1268
- break;
1269
- }
1270
- default: {
1271
- if ((e) instanceof Error) {
1272
- console.error(e);
1273
- }
1274
-
1275
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
1276
- }
1277
- }
1278
- dataView(memory0).setInt8(arg2 + 4, enum4, true);
1279
- break;
1280
- }
1281
- default: {
1282
- throw new TypeError('invalid variant specified for result');
1283
- }
1284
- }
1285
- }
1286
-
1287
-
1288
- function trampoline17(arg0, arg1, arg2) {
1289
- var handle1 = arg0;
1290
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1291
- var rsc0 = captureTable5.get(rep2);
1292
- if (!rsc0) {
1293
- rsc0 = Object.create(Descriptor.prototype);
1294
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
1295
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1296
- }
1297
- curResourceBorrows.push(rsc0);
1298
- let ret;
1299
- try {
1300
- ret = { tag: 'ok', val: rsc0.writeViaStream(BigInt.asUintN(64, arg1))};
1301
- } catch (e) {
1302
- ret = { tag: 'err', val: getErrorPayload(e) };
1303
- }
1304
- for (const rsc of curResourceBorrows) {
1305
- rsc[symbolRscHandle] = undefined;
1306
- }
1307
- curResourceBorrows = [];
1308
- var variant5 = ret;
1309
- switch (variant5.tag) {
1310
- case 'ok': {
1311
- const e = variant5.val;
1312
- dataView(memory0).setInt8(arg2 + 0, 0, true);
1313
- if (!(e instanceof OutputStream)) {
1314
- throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
1315
- }
1316
- var handle3 = e[symbolRscHandle];
1317
- if (!handle3) {
1318
- const rep = e[symbolRscRep] || ++captureCnt2;
1319
- captureTable2.set(rep, e);
1320
- handle3 = rscTableCreateOwn(handleTable2, rep);
1321
- }
1322
- dataView(memory0).setInt32(arg2 + 4, handle3, true);
1323
- break;
1324
- }
1325
- case 'err': {
1326
- const e = variant5.val;
1327
- dataView(memory0).setInt8(arg2 + 0, 1, true);
1328
- var val4 = e;
1329
- let enum4;
1330
- switch (val4) {
1331
- case 'access': {
1332
- enum4 = 0;
1333
- break;
1334
- }
1335
- case 'would-block': {
1336
- enum4 = 1;
1337
- break;
1338
- }
1339
- case 'already': {
1340
- enum4 = 2;
1341
- break;
1342
- }
1343
- case 'bad-descriptor': {
1344
- enum4 = 3;
1345
- break;
1346
- }
1347
- case 'busy': {
1348
- enum4 = 4;
1349
- break;
1350
- }
1351
- case 'deadlock': {
1352
- enum4 = 5;
1353
- break;
1354
- }
1355
- case 'quota': {
1356
- enum4 = 6;
1357
- break;
1358
- }
1359
- case 'exist': {
1360
- enum4 = 7;
1361
- break;
1362
- }
1363
- case 'file-too-large': {
1364
- enum4 = 8;
1365
- break;
1366
- }
1367
- case 'illegal-byte-sequence': {
1368
- enum4 = 9;
1369
- break;
1370
- }
1371
- case 'in-progress': {
1372
- enum4 = 10;
1373
- break;
1374
- }
1375
- case 'interrupted': {
1376
- enum4 = 11;
1377
- break;
1378
- }
1379
- case 'invalid': {
1380
- enum4 = 12;
1381
- break;
1382
- }
1383
- case 'io': {
1384
- enum4 = 13;
1385
- break;
1386
- }
1387
- case 'is-directory': {
1388
- enum4 = 14;
1389
- break;
1390
- }
1391
- case 'loop': {
1392
- enum4 = 15;
1393
- break;
1394
- }
1395
- case 'too-many-links': {
1396
- enum4 = 16;
1397
- break;
1398
- }
1399
- case 'message-size': {
1400
- enum4 = 17;
1401
- break;
1402
- }
1403
- case 'name-too-long': {
1404
- enum4 = 18;
1405
- break;
1406
- }
1407
- case 'no-device': {
1408
- enum4 = 19;
1409
- break;
1410
- }
1411
- case 'no-entry': {
1412
- enum4 = 20;
1413
- break;
1414
- }
1415
- case 'no-lock': {
1416
- enum4 = 21;
1417
- break;
1418
- }
1419
- case 'insufficient-memory': {
1420
- enum4 = 22;
1421
- break;
1422
- }
1423
- case 'insufficient-space': {
1424
- enum4 = 23;
1425
- break;
1426
- }
1427
- case 'not-directory': {
1428
- enum4 = 24;
1429
- break;
1430
- }
1431
- case 'not-empty': {
1432
- enum4 = 25;
1433
- break;
1434
- }
1435
- case 'not-recoverable': {
1436
- enum4 = 26;
1437
- break;
1438
- }
1439
- case 'unsupported': {
1440
- enum4 = 27;
1441
- break;
1442
- }
1443
- case 'no-tty': {
1444
- enum4 = 28;
1445
- break;
1446
- }
1447
- case 'no-such-device': {
1448
- enum4 = 29;
1449
- break;
1450
- }
1451
- case 'overflow': {
1452
- enum4 = 30;
1453
- break;
1454
- }
1455
- case 'not-permitted': {
1456
- enum4 = 31;
1457
- break;
1458
- }
1459
- case 'pipe': {
1460
- enum4 = 32;
1461
- break;
1462
- }
1463
- case 'read-only': {
1464
- enum4 = 33;
1465
- break;
1466
- }
1467
- case 'invalid-seek': {
1468
- enum4 = 34;
1469
- break;
1470
- }
1471
- case 'text-file-busy': {
1472
- enum4 = 35;
1473
- break;
1474
- }
1475
- case 'cross-device': {
1476
- enum4 = 36;
1477
- break;
1478
- }
1479
- default: {
1480
- if ((e) instanceof Error) {
1481
- console.error(e);
1482
- }
1483
-
1484
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
1485
- }
1486
- }
1487
- dataView(memory0).setInt8(arg2 + 4, enum4, true);
1488
- break;
1489
- }
1490
- default: {
1491
- throw new TypeError('invalid variant specified for result');
1492
- }
1493
- }
1494
- }
1495
-
1496
-
1497
- function trampoline18(arg0, arg1) {
1498
- var handle1 = arg0;
1499
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1500
- var rsc0 = captureTable5.get(rep2);
1501
- if (!rsc0) {
1502
- rsc0 = Object.create(Descriptor.prototype);
1503
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
1504
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1505
- }
1506
- curResourceBorrows.push(rsc0);
1507
- let ret;
1508
- try {
1509
- ret = { tag: 'ok', val: rsc0.appendViaStream()};
1510
- } catch (e) {
1511
- ret = { tag: 'err', val: getErrorPayload(e) };
1512
- }
1513
- for (const rsc of curResourceBorrows) {
1514
- rsc[symbolRscHandle] = undefined;
1515
- }
1516
- curResourceBorrows = [];
1517
- var variant5 = ret;
1518
- switch (variant5.tag) {
1519
- case 'ok': {
1520
- const e = variant5.val;
1521
- dataView(memory0).setInt8(arg1 + 0, 0, true);
1522
- if (!(e instanceof OutputStream)) {
1523
- throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
1524
- }
1525
- var handle3 = e[symbolRscHandle];
1526
- if (!handle3) {
1527
- const rep = e[symbolRscRep] || ++captureCnt2;
1528
- captureTable2.set(rep, e);
1529
- handle3 = rscTableCreateOwn(handleTable2, rep);
1530
- }
1531
- dataView(memory0).setInt32(arg1 + 4, handle3, true);
1532
- break;
1533
- }
1534
- case 'err': {
1535
- const e = variant5.val;
1536
- dataView(memory0).setInt8(arg1 + 0, 1, true);
1537
- var val4 = e;
1538
- let enum4;
1539
- switch (val4) {
1540
- case 'access': {
1541
- enum4 = 0;
1542
- break;
1543
- }
1544
- case 'would-block': {
1545
- enum4 = 1;
1546
- break;
1547
- }
1548
- case 'already': {
1549
- enum4 = 2;
1550
- break;
1551
- }
1552
- case 'bad-descriptor': {
1553
- enum4 = 3;
1554
- break;
1555
- }
1556
- case 'busy': {
1557
- enum4 = 4;
1558
- break;
1559
- }
1560
- case 'deadlock': {
1561
- enum4 = 5;
1562
- break;
1563
- }
1564
- case 'quota': {
1565
- enum4 = 6;
1566
- break;
1567
- }
1568
- case 'exist': {
1569
- enum4 = 7;
1570
- break;
1571
- }
1572
- case 'file-too-large': {
1573
- enum4 = 8;
1574
- break;
1575
- }
1576
- case 'illegal-byte-sequence': {
1577
- enum4 = 9;
1578
- break;
1579
- }
1580
- case 'in-progress': {
1581
- enum4 = 10;
1582
- break;
1583
- }
1584
- case 'interrupted': {
1585
- enum4 = 11;
1586
- break;
1587
- }
1588
- case 'invalid': {
1589
- enum4 = 12;
1590
- break;
1591
- }
1592
- case 'io': {
1593
- enum4 = 13;
1594
- break;
1595
- }
1596
- case 'is-directory': {
1597
- enum4 = 14;
1598
- break;
1599
- }
1600
- case 'loop': {
1601
- enum4 = 15;
1602
- break;
1603
- }
1604
- case 'too-many-links': {
1605
- enum4 = 16;
1606
- break;
1607
- }
1608
- case 'message-size': {
1609
- enum4 = 17;
1610
- break;
1611
- }
1612
- case 'name-too-long': {
1613
- enum4 = 18;
1614
- break;
1615
- }
1616
- case 'no-device': {
1617
- enum4 = 19;
1618
- break;
1619
- }
1620
- case 'no-entry': {
1621
- enum4 = 20;
1622
- break;
1623
- }
1624
- case 'no-lock': {
1625
- enum4 = 21;
1626
- break;
1627
- }
1628
- case 'insufficient-memory': {
1629
- enum4 = 22;
1630
- break;
1631
- }
1632
- case 'insufficient-space': {
1633
- enum4 = 23;
1634
- break;
1635
- }
1636
- case 'not-directory': {
1637
- enum4 = 24;
1638
- break;
1639
- }
1640
- case 'not-empty': {
1641
- enum4 = 25;
1642
- break;
1643
- }
1644
- case 'not-recoverable': {
1645
- enum4 = 26;
1646
- break;
1647
- }
1648
- case 'unsupported': {
1649
- enum4 = 27;
1650
- break;
1651
- }
1652
- case 'no-tty': {
1653
- enum4 = 28;
1654
- break;
1655
- }
1656
- case 'no-such-device': {
1657
- enum4 = 29;
1658
- break;
1659
- }
1660
- case 'overflow': {
1661
- enum4 = 30;
1662
- break;
1663
- }
1664
- case 'not-permitted': {
1665
- enum4 = 31;
1666
- break;
1667
- }
1668
- case 'pipe': {
1669
- enum4 = 32;
1670
- break;
1671
- }
1672
- case 'read-only': {
1673
- enum4 = 33;
1674
- break;
1675
- }
1676
- case 'invalid-seek': {
1677
- enum4 = 34;
1678
- break;
1679
- }
1680
- case 'text-file-busy': {
1681
- enum4 = 35;
1682
- break;
1683
- }
1684
- case 'cross-device': {
1685
- enum4 = 36;
1686
- break;
1687
- }
1688
- default: {
1689
- if ((e) instanceof Error) {
1690
- console.error(e);
1691
- }
1692
-
1693
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
1694
- }
1695
- }
1696
- dataView(memory0).setInt8(arg1 + 4, enum4, true);
1697
- break;
1698
- }
1699
- default: {
1700
- throw new TypeError('invalid variant specified for result');
1701
- }
1702
- }
1703
- }
1704
-
1705
- const handleTable6 = [T_FLAG, 0];
1706
- const captureTable6= new Map();
1707
- let captureCnt6 = 0;
1708
- handleTables[6] = handleTable6;
1709
-
1710
- function trampoline19(arg0, arg1) {
1711
- var handle1 = arg0;
1712
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1713
- var rsc0 = captureTable5.get(rep2);
1714
- if (!rsc0) {
1715
- rsc0 = Object.create(Descriptor.prototype);
1716
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
1717
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1718
- }
1719
- curResourceBorrows.push(rsc0);
1720
- let ret;
1721
- try {
1722
- ret = { tag: 'ok', val: rsc0.readDirectory()};
1723
- } catch (e) {
1724
- ret = { tag: 'err', val: getErrorPayload(e) };
1725
- }
1726
- for (const rsc of curResourceBorrows) {
1727
- rsc[symbolRscHandle] = undefined;
1728
- }
1729
- curResourceBorrows = [];
1730
- var variant5 = ret;
1731
- switch (variant5.tag) {
1732
- case 'ok': {
1733
- const e = variant5.val;
1734
- dataView(memory0).setInt8(arg1 + 0, 0, true);
1735
- if (!(e instanceof DirectoryEntryStream)) {
1736
- throw new TypeError('Resource error: Not a valid "DirectoryEntryStream" resource.');
1737
- }
1738
- var handle3 = e[symbolRscHandle];
1739
- if (!handle3) {
1740
- const rep = e[symbolRscRep] || ++captureCnt6;
1741
- captureTable6.set(rep, e);
1742
- handle3 = rscTableCreateOwn(handleTable6, rep);
1743
- }
1744
- dataView(memory0).setInt32(arg1 + 4, handle3, true);
1745
- break;
1746
- }
1747
- case 'err': {
1748
- const e = variant5.val;
1749
- dataView(memory0).setInt8(arg1 + 0, 1, true);
1750
- var val4 = e;
1751
- let enum4;
1752
- switch (val4) {
1753
- case 'access': {
1754
- enum4 = 0;
1755
- break;
1756
- }
1757
- case 'would-block': {
1758
- enum4 = 1;
1759
- break;
1760
- }
1761
- case 'already': {
1762
- enum4 = 2;
1763
- break;
1764
- }
1765
- case 'bad-descriptor': {
1766
- enum4 = 3;
1767
- break;
1768
- }
1769
- case 'busy': {
1770
- enum4 = 4;
1771
- break;
1772
- }
1773
- case 'deadlock': {
1774
- enum4 = 5;
1775
- break;
1776
- }
1777
- case 'quota': {
1778
- enum4 = 6;
1779
- break;
1780
- }
1781
- case 'exist': {
1782
- enum4 = 7;
1783
- break;
1784
- }
1785
- case 'file-too-large': {
1786
- enum4 = 8;
1787
- break;
1788
- }
1789
- case 'illegal-byte-sequence': {
1790
- enum4 = 9;
1791
- break;
1792
- }
1793
- case 'in-progress': {
1794
- enum4 = 10;
1795
- break;
1796
- }
1797
- case 'interrupted': {
1798
- enum4 = 11;
1799
- break;
1800
- }
1801
- case 'invalid': {
1802
- enum4 = 12;
1803
- break;
1804
- }
1805
- case 'io': {
1806
- enum4 = 13;
1807
- break;
1808
- }
1809
- case 'is-directory': {
1810
- enum4 = 14;
1811
- break;
1812
- }
1813
- case 'loop': {
1814
- enum4 = 15;
1815
- break;
1816
- }
1817
- case 'too-many-links': {
1818
- enum4 = 16;
1819
- break;
1820
- }
1821
- case 'message-size': {
1822
- enum4 = 17;
1823
- break;
1824
- }
1825
- case 'name-too-long': {
1826
- enum4 = 18;
1827
- break;
1828
- }
1829
- case 'no-device': {
1830
- enum4 = 19;
1831
- break;
1832
- }
1833
- case 'no-entry': {
1834
- enum4 = 20;
1835
- break;
1836
- }
1837
- case 'no-lock': {
1838
- enum4 = 21;
1839
- break;
1840
- }
1841
- case 'insufficient-memory': {
1842
- enum4 = 22;
1843
- break;
1844
- }
1845
- case 'insufficient-space': {
1846
- enum4 = 23;
1847
- break;
1848
- }
1849
- case 'not-directory': {
1850
- enum4 = 24;
1851
- break;
1852
- }
1853
- case 'not-empty': {
1854
- enum4 = 25;
1855
- break;
1856
- }
1857
- case 'not-recoverable': {
1858
- enum4 = 26;
1859
- break;
1860
- }
1861
- case 'unsupported': {
1862
- enum4 = 27;
1863
- break;
1864
- }
1865
- case 'no-tty': {
1866
- enum4 = 28;
1867
- break;
1868
- }
1869
- case 'no-such-device': {
1870
- enum4 = 29;
1871
- break;
1872
- }
1873
- case 'overflow': {
1874
- enum4 = 30;
1875
- break;
1876
- }
1877
- case 'not-permitted': {
1878
- enum4 = 31;
1879
- break;
1880
- }
1881
- case 'pipe': {
1882
- enum4 = 32;
1883
- break;
1884
- }
1885
- case 'read-only': {
1886
- enum4 = 33;
1887
- break;
1888
- }
1889
- case 'invalid-seek': {
1890
- enum4 = 34;
1891
- break;
1892
- }
1893
- case 'text-file-busy': {
1894
- enum4 = 35;
1895
- break;
1896
- }
1897
- case 'cross-device': {
1898
- enum4 = 36;
1899
- break;
1900
- }
1901
- default: {
1902
- if ((e) instanceof Error) {
1903
- console.error(e);
1904
- }
1905
-
1906
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
1907
- }
1908
- }
1909
- dataView(memory0).setInt8(arg1 + 4, enum4, true);
1910
- break;
1911
- }
1912
- default: {
1913
- throw new TypeError('invalid variant specified for result');
1914
- }
1915
- }
1916
- }
1917
-
1918
-
1919
- function trampoline20(arg0, arg1) {
1920
- var handle1 = arg0;
1921
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1922
- var rsc0 = captureTable5.get(rep2);
1923
- if (!rsc0) {
1924
- rsc0 = Object.create(Descriptor.prototype);
1925
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
1926
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1927
- }
1928
- curResourceBorrows.push(rsc0);
1929
- let ret;
1930
- try {
1931
- ret = { tag: 'ok', val: rsc0.stat()};
1932
- } catch (e) {
1933
- ret = { tag: 'err', val: getErrorPayload(e) };
1934
- }
1935
- for (const rsc of curResourceBorrows) {
1936
- rsc[symbolRscHandle] = undefined;
1937
- }
1938
- curResourceBorrows = [];
1939
- var variant12 = ret;
1940
- switch (variant12.tag) {
1941
- case 'ok': {
1942
- const e = variant12.val;
1943
- dataView(memory0).setInt8(arg1 + 0, 0, true);
1944
- var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
1945
- var val4 = v3_0;
1946
- let enum4;
1947
- switch (val4) {
1948
- case 'unknown': {
1949
- enum4 = 0;
1950
- break;
1951
- }
1952
- case 'block-device': {
1953
- enum4 = 1;
1954
- break;
1955
- }
1956
- case 'character-device': {
1957
- enum4 = 2;
1958
- break;
1959
- }
1960
- case 'directory': {
1961
- enum4 = 3;
1962
- break;
1963
- }
1964
- case 'fifo': {
1965
- enum4 = 4;
1966
- break;
1967
- }
1968
- case 'symbolic-link': {
1969
- enum4 = 5;
1970
- break;
1971
- }
1972
- case 'regular-file': {
1973
- enum4 = 6;
1974
- break;
1975
- }
1976
- case 'socket': {
1977
- enum4 = 7;
1978
- break;
1979
- }
1980
- default: {
1981
- if ((v3_0) instanceof Error) {
1982
- console.error(v3_0);
1983
- }
1984
-
1985
- throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
1986
- }
1987
- }
1988
- dataView(memory0).setInt8(arg1 + 8, enum4, true);
1989
- dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
1990
- dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
1991
- var variant6 = v3_3;
1992
- if (variant6 === null || variant6=== undefined) {
1993
- dataView(memory0).setInt8(arg1 + 32, 0, true);
1994
- } else {
1995
- const e = variant6;
1996
- dataView(memory0).setInt8(arg1 + 32, 1, true);
1997
- var {seconds: v5_0, nanoseconds: v5_1 } = e;
1998
- dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
1999
- dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
2000
- }
2001
- var variant8 = v3_4;
2002
- if (variant8 === null || variant8=== undefined) {
2003
- dataView(memory0).setInt8(arg1 + 56, 0, true);
2004
- } else {
2005
- const e = variant8;
2006
- dataView(memory0).setInt8(arg1 + 56, 1, true);
2007
- var {seconds: v7_0, nanoseconds: v7_1 } = e;
2008
- dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
2009
- dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
2010
- }
2011
- var variant10 = v3_5;
2012
- if (variant10 === null || variant10=== undefined) {
2013
- dataView(memory0).setInt8(arg1 + 80, 0, true);
2014
- } else {
2015
- const e = variant10;
2016
- dataView(memory0).setInt8(arg1 + 80, 1, true);
2017
- var {seconds: v9_0, nanoseconds: v9_1 } = e;
2018
- dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
2019
- dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
2020
- }
2021
- break;
2022
- }
2023
- case 'err': {
2024
- const e = variant12.val;
2025
- dataView(memory0).setInt8(arg1 + 0, 1, true);
2026
- var val11 = e;
2027
- let enum11;
2028
- switch (val11) {
2029
- case 'access': {
2030
- enum11 = 0;
2031
- break;
2032
- }
2033
- case 'would-block': {
2034
- enum11 = 1;
2035
- break;
2036
- }
2037
- case 'already': {
2038
- enum11 = 2;
2039
- break;
2040
- }
2041
- case 'bad-descriptor': {
2042
- enum11 = 3;
2043
- break;
2044
- }
2045
- case 'busy': {
2046
- enum11 = 4;
2047
- break;
2048
- }
2049
- case 'deadlock': {
2050
- enum11 = 5;
2051
- break;
2052
- }
2053
- case 'quota': {
2054
- enum11 = 6;
2055
- break;
2056
- }
2057
- case 'exist': {
2058
- enum11 = 7;
2059
- break;
2060
- }
2061
- case 'file-too-large': {
2062
- enum11 = 8;
2063
- break;
2064
- }
2065
- case 'illegal-byte-sequence': {
2066
- enum11 = 9;
2067
- break;
2068
- }
2069
- case 'in-progress': {
2070
- enum11 = 10;
2071
- break;
2072
- }
2073
- case 'interrupted': {
2074
- enum11 = 11;
2075
- break;
2076
- }
2077
- case 'invalid': {
2078
- enum11 = 12;
2079
- break;
2080
- }
2081
- case 'io': {
2082
- enum11 = 13;
2083
- break;
2084
- }
2085
- case 'is-directory': {
2086
- enum11 = 14;
2087
- break;
2088
- }
2089
- case 'loop': {
2090
- enum11 = 15;
2091
- break;
2092
- }
2093
- case 'too-many-links': {
2094
- enum11 = 16;
2095
- break;
2096
- }
2097
- case 'message-size': {
2098
- enum11 = 17;
2099
- break;
2100
- }
2101
- case 'name-too-long': {
2102
- enum11 = 18;
2103
- break;
2104
- }
2105
- case 'no-device': {
2106
- enum11 = 19;
2107
- break;
2108
- }
2109
- case 'no-entry': {
2110
- enum11 = 20;
2111
- break;
2112
- }
2113
- case 'no-lock': {
2114
- enum11 = 21;
2115
- break;
2116
- }
2117
- case 'insufficient-memory': {
2118
- enum11 = 22;
2119
- break;
2120
- }
2121
- case 'insufficient-space': {
2122
- enum11 = 23;
2123
- break;
2124
- }
2125
- case 'not-directory': {
2126
- enum11 = 24;
2127
- break;
2128
- }
2129
- case 'not-empty': {
2130
- enum11 = 25;
2131
- break;
2132
- }
2133
- case 'not-recoverable': {
2134
- enum11 = 26;
2135
- break;
2136
- }
2137
- case 'unsupported': {
2138
- enum11 = 27;
2139
- break;
2140
- }
2141
- case 'no-tty': {
2142
- enum11 = 28;
2143
- break;
2144
- }
2145
- case 'no-such-device': {
2146
- enum11 = 29;
2147
- break;
2148
- }
2149
- case 'overflow': {
2150
- enum11 = 30;
2151
- break;
2152
- }
2153
- case 'not-permitted': {
2154
- enum11 = 31;
2155
- break;
2156
- }
2157
- case 'pipe': {
2158
- enum11 = 32;
2159
- break;
2160
- }
2161
- case 'read-only': {
2162
- enum11 = 33;
2163
- break;
2164
- }
2165
- case 'invalid-seek': {
2166
- enum11 = 34;
2167
- break;
2168
- }
2169
- case 'text-file-busy': {
2170
- enum11 = 35;
2171
- break;
2172
- }
2173
- case 'cross-device': {
2174
- enum11 = 36;
2175
- break;
2176
- }
2177
- default: {
2178
- if ((e) instanceof Error) {
2179
- console.error(e);
2180
- }
2181
-
2182
- throw new TypeError(`"${val11}" is not one of the cases of error-code`);
2183
- }
2184
- }
2185
- dataView(memory0).setInt8(arg1 + 8, enum11, true);
2186
- break;
2187
- }
2188
- default: {
2189
- throw new TypeError('invalid variant specified for result');
2190
- }
2191
- }
2192
- }
2193
-
2194
-
2195
- function trampoline21(arg0, arg1, arg2, arg3, arg4) {
2196
- var handle1 = arg0;
2197
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
2198
- var rsc0 = captureTable5.get(rep2);
2199
- if (!rsc0) {
2200
- rsc0 = Object.create(Descriptor.prototype);
2201
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
2202
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
2203
- }
2204
- curResourceBorrows.push(rsc0);
2205
- if ((arg1 & 4294967294) !== 0) {
2206
- throw new TypeError('flags have extraneous bits set');
2207
- }
2208
- var flags3 = {
2209
- symlinkFollow: Boolean(arg1 & 1),
2210
- };
2211
- var ptr4 = arg2;
2212
- var len4 = arg3;
2213
- var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
2214
- let ret;
2215
- try {
2216
- ret = { tag: 'ok', val: rsc0.statAt(flags3, result4)};
2217
- } catch (e) {
2218
- ret = { tag: 'err', val: getErrorPayload(e) };
2219
- }
2220
- for (const rsc of curResourceBorrows) {
2221
- rsc[symbolRscHandle] = undefined;
2222
- }
2223
- curResourceBorrows = [];
2224
- var variant14 = ret;
2225
- switch (variant14.tag) {
2226
- case 'ok': {
2227
- const e = variant14.val;
2228
- dataView(memory0).setInt8(arg4 + 0, 0, true);
2229
- var {type: v5_0, linkCount: v5_1, size: v5_2, dataAccessTimestamp: v5_3, dataModificationTimestamp: v5_4, statusChangeTimestamp: v5_5 } = e;
2230
- var val6 = v5_0;
2231
- let enum6;
2232
- switch (val6) {
2233
- case 'unknown': {
2234
- enum6 = 0;
2235
- break;
2236
- }
2237
- case 'block-device': {
2238
- enum6 = 1;
2239
- break;
2240
- }
2241
- case 'character-device': {
2242
- enum6 = 2;
2243
- break;
2244
- }
2245
- case 'directory': {
2246
- enum6 = 3;
2247
- break;
2248
- }
2249
- case 'fifo': {
2250
- enum6 = 4;
2251
- break;
2252
- }
2253
- case 'symbolic-link': {
2254
- enum6 = 5;
2255
- break;
2256
- }
2257
- case 'regular-file': {
2258
- enum6 = 6;
2259
- break;
2260
- }
2261
- case 'socket': {
2262
- enum6 = 7;
2263
- break;
2264
- }
2265
- default: {
2266
- if ((v5_0) instanceof Error) {
2267
- console.error(v5_0);
2268
- }
2269
-
2270
- throw new TypeError(`"${val6}" is not one of the cases of descriptor-type`);
2271
- }
2272
- }
2273
- dataView(memory0).setInt8(arg4 + 8, enum6, true);
2274
- dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
2275
- dataView(memory0).setBigInt64(arg4 + 24, toUint64(v5_2), true);
2276
- var variant8 = v5_3;
2277
- if (variant8 === null || variant8=== undefined) {
2278
- dataView(memory0).setInt8(arg4 + 32, 0, true);
2279
- } else {
2280
- const e = variant8;
2281
- dataView(memory0).setInt8(arg4 + 32, 1, true);
2282
- var {seconds: v7_0, nanoseconds: v7_1 } = e;
2283
- dataView(memory0).setBigInt64(arg4 + 40, toUint64(v7_0), true);
2284
- dataView(memory0).setInt32(arg4 + 48, toUint32(v7_1), true);
2285
- }
2286
- var variant10 = v5_4;
2287
- if (variant10 === null || variant10=== undefined) {
2288
- dataView(memory0).setInt8(arg4 + 56, 0, true);
2289
- } else {
2290
- const e = variant10;
2291
- dataView(memory0).setInt8(arg4 + 56, 1, true);
2292
- var {seconds: v9_0, nanoseconds: v9_1 } = e;
2293
- dataView(memory0).setBigInt64(arg4 + 64, toUint64(v9_0), true);
2294
- dataView(memory0).setInt32(arg4 + 72, toUint32(v9_1), true);
2295
- }
2296
- var variant12 = v5_5;
2297
- if (variant12 === null || variant12=== undefined) {
2298
- dataView(memory0).setInt8(arg4 + 80, 0, true);
2299
- } else {
2300
- const e = variant12;
2301
- dataView(memory0).setInt8(arg4 + 80, 1, true);
2302
- var {seconds: v11_0, nanoseconds: v11_1 } = e;
2303
- dataView(memory0).setBigInt64(arg4 + 88, toUint64(v11_0), true);
2304
- dataView(memory0).setInt32(arg4 + 96, toUint32(v11_1), true);
2305
- }
2306
- break;
2307
- }
2308
- case 'err': {
2309
- const e = variant14.val;
2310
- dataView(memory0).setInt8(arg4 + 0, 1, true);
2311
- var val13 = e;
2312
- let enum13;
2313
- switch (val13) {
2314
- case 'access': {
2315
- enum13 = 0;
2316
- break;
2317
- }
2318
- case 'would-block': {
2319
- enum13 = 1;
2320
- break;
2321
- }
2322
- case 'already': {
2323
- enum13 = 2;
2324
- break;
2325
- }
2326
- case 'bad-descriptor': {
2327
- enum13 = 3;
2328
- break;
2329
- }
2330
- case 'busy': {
2331
- enum13 = 4;
2332
- break;
2333
- }
2334
- case 'deadlock': {
2335
- enum13 = 5;
2336
- break;
2337
- }
2338
- case 'quota': {
2339
- enum13 = 6;
2340
- break;
2341
- }
2342
- case 'exist': {
2343
- enum13 = 7;
2344
- break;
2345
- }
2346
- case 'file-too-large': {
2347
- enum13 = 8;
2348
- break;
2349
- }
2350
- case 'illegal-byte-sequence': {
2351
- enum13 = 9;
2352
- break;
2353
- }
2354
- case 'in-progress': {
2355
- enum13 = 10;
2356
- break;
2357
- }
2358
- case 'interrupted': {
2359
- enum13 = 11;
2360
- break;
2361
- }
2362
- case 'invalid': {
2363
- enum13 = 12;
2364
- break;
2365
- }
2366
- case 'io': {
2367
- enum13 = 13;
2368
- break;
2369
- }
2370
- case 'is-directory': {
2371
- enum13 = 14;
2372
- break;
2373
- }
2374
- case 'loop': {
2375
- enum13 = 15;
2376
- break;
2377
- }
2378
- case 'too-many-links': {
2379
- enum13 = 16;
2380
- break;
2381
- }
2382
- case 'message-size': {
2383
- enum13 = 17;
2384
- break;
2385
- }
2386
- case 'name-too-long': {
2387
- enum13 = 18;
2388
- break;
2389
- }
2390
- case 'no-device': {
2391
- enum13 = 19;
2392
- break;
2393
- }
2394
- case 'no-entry': {
2395
- enum13 = 20;
2396
- break;
2397
- }
2398
- case 'no-lock': {
2399
- enum13 = 21;
2400
- break;
2401
- }
2402
- case 'insufficient-memory': {
2403
- enum13 = 22;
2404
- break;
2405
- }
2406
- case 'insufficient-space': {
2407
- enum13 = 23;
2408
- break;
2409
- }
2410
- case 'not-directory': {
2411
- enum13 = 24;
2412
- break;
2413
- }
2414
- case 'not-empty': {
2415
- enum13 = 25;
2416
- break;
2417
- }
2418
- case 'not-recoverable': {
2419
- enum13 = 26;
2420
- break;
2421
- }
2422
- case 'unsupported': {
2423
- enum13 = 27;
2424
- break;
2425
- }
2426
- case 'no-tty': {
2427
- enum13 = 28;
2428
- break;
2429
- }
2430
- case 'no-such-device': {
2431
- enum13 = 29;
2432
- break;
2433
- }
2434
- case 'overflow': {
2435
- enum13 = 30;
2436
- break;
2437
- }
2438
- case 'not-permitted': {
2439
- enum13 = 31;
2440
- break;
2441
- }
2442
- case 'pipe': {
2443
- enum13 = 32;
2444
- break;
2445
- }
2446
- case 'read-only': {
2447
- enum13 = 33;
2448
- break;
2449
- }
2450
- case 'invalid-seek': {
2451
- enum13 = 34;
2452
- break;
2453
- }
2454
- case 'text-file-busy': {
2455
- enum13 = 35;
2456
- break;
2457
- }
2458
- case 'cross-device': {
2459
- enum13 = 36;
2460
- break;
2461
- }
2462
- default: {
2463
- if ((e) instanceof Error) {
2464
- console.error(e);
2465
- }
2466
-
2467
- throw new TypeError(`"${val13}" is not one of the cases of error-code`);
2468
- }
2469
- }
2470
- dataView(memory0).setInt8(arg4 + 8, enum13, true);
2471
- break;
2472
- }
2473
- default: {
2474
- throw new TypeError('invalid variant specified for result');
2475
- }
2476
- }
2477
- }
2478
-
2479
-
2480
- function trampoline22(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
2481
- var handle1 = arg0;
2482
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
2483
- var rsc0 = captureTable5.get(rep2);
2484
- if (!rsc0) {
2485
- rsc0 = Object.create(Descriptor.prototype);
2486
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
2487
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
2488
- }
2489
- curResourceBorrows.push(rsc0);
2490
- if ((arg1 & 4294967294) !== 0) {
2491
- throw new TypeError('flags have extraneous bits set');
2492
- }
2493
- var flags3 = {
2494
- symlinkFollow: Boolean(arg1 & 1),
2495
- };
2496
- var ptr4 = arg2;
2497
- var len4 = arg3;
2498
- var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
2499
- if ((arg4 & 4294967280) !== 0) {
2500
- throw new TypeError('flags have extraneous bits set');
2501
- }
2502
- var flags5 = {
2503
- create: Boolean(arg4 & 1),
2504
- directory: Boolean(arg4 & 2),
2505
- exclusive: Boolean(arg4 & 4),
2506
- truncate: Boolean(arg4 & 8),
2507
- };
2508
- if ((arg5 & 4294967232) !== 0) {
2509
- throw new TypeError('flags have extraneous bits set');
2510
- }
2511
- var flags6 = {
2512
- read: Boolean(arg5 & 1),
2513
- write: Boolean(arg5 & 2),
2514
- fileIntegritySync: Boolean(arg5 & 4),
2515
- dataIntegritySync: Boolean(arg5 & 8),
2516
- requestedWriteSync: Boolean(arg5 & 16),
2517
- mutateDirectory: Boolean(arg5 & 32),
2518
- };
2519
- let ret;
2520
- try {
2521
- ret = { tag: 'ok', val: rsc0.openAt(flags3, result4, flags5, flags6)};
2522
- } catch (e) {
2523
- ret = { tag: 'err', val: getErrorPayload(e) };
2524
- }
2525
- for (const rsc of curResourceBorrows) {
2526
- rsc[symbolRscHandle] = undefined;
2527
- }
2528
- curResourceBorrows = [];
2529
- var variant9 = ret;
2530
- switch (variant9.tag) {
2531
- case 'ok': {
2532
- const e = variant9.val;
2533
- dataView(memory0).setInt8(arg6 + 0, 0, true);
2534
- if (!(e instanceof Descriptor)) {
2535
- throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
2536
- }
2537
- var handle7 = e[symbolRscHandle];
2538
- if (!handle7) {
2539
- const rep = e[symbolRscRep] || ++captureCnt5;
2540
- captureTable5.set(rep, e);
2541
- handle7 = rscTableCreateOwn(handleTable5, rep);
2542
- }
2543
- dataView(memory0).setInt32(arg6 + 4, handle7, true);
2544
- break;
2545
- }
2546
- case 'err': {
2547
- const e = variant9.val;
2548
- dataView(memory0).setInt8(arg6 + 0, 1, true);
2549
- var val8 = e;
2550
- let enum8;
2551
- switch (val8) {
2552
- case 'access': {
2553
- enum8 = 0;
2554
- break;
2555
- }
2556
- case 'would-block': {
2557
- enum8 = 1;
2558
- break;
2559
- }
2560
- case 'already': {
2561
- enum8 = 2;
2562
- break;
2563
- }
2564
- case 'bad-descriptor': {
2565
- enum8 = 3;
2566
- break;
2567
- }
2568
- case 'busy': {
2569
- enum8 = 4;
2570
- break;
2571
- }
2572
- case 'deadlock': {
2573
- enum8 = 5;
2574
- break;
2575
- }
2576
- case 'quota': {
2577
- enum8 = 6;
2578
- break;
2579
- }
2580
- case 'exist': {
2581
- enum8 = 7;
2582
- break;
2583
- }
2584
- case 'file-too-large': {
2585
- enum8 = 8;
2586
- break;
2587
- }
2588
- case 'illegal-byte-sequence': {
2589
- enum8 = 9;
2590
- break;
2591
- }
2592
- case 'in-progress': {
2593
- enum8 = 10;
2594
- break;
2595
- }
2596
- case 'interrupted': {
2597
- enum8 = 11;
2598
- break;
2599
- }
2600
- case 'invalid': {
2601
- enum8 = 12;
2602
- break;
2603
- }
2604
- case 'io': {
2605
- enum8 = 13;
2606
- break;
2607
- }
2608
- case 'is-directory': {
2609
- enum8 = 14;
2610
- break;
2611
- }
2612
- case 'loop': {
2613
- enum8 = 15;
2614
- break;
2615
- }
2616
- case 'too-many-links': {
2617
- enum8 = 16;
2618
- break;
2619
- }
2620
- case 'message-size': {
2621
- enum8 = 17;
2622
- break;
2623
- }
2624
- case 'name-too-long': {
2625
- enum8 = 18;
2626
- break;
2627
- }
2628
- case 'no-device': {
2629
- enum8 = 19;
2630
- break;
2631
- }
2632
- case 'no-entry': {
2633
- enum8 = 20;
2634
- break;
2635
- }
2636
- case 'no-lock': {
2637
- enum8 = 21;
2638
- break;
2639
- }
2640
- case 'insufficient-memory': {
2641
- enum8 = 22;
2642
- break;
2643
- }
2644
- case 'insufficient-space': {
2645
- enum8 = 23;
2646
- break;
2647
- }
2648
- case 'not-directory': {
2649
- enum8 = 24;
2650
- break;
2651
- }
2652
- case 'not-empty': {
2653
- enum8 = 25;
2654
- break;
2655
- }
2656
- case 'not-recoverable': {
2657
- enum8 = 26;
2658
- break;
2659
- }
2660
- case 'unsupported': {
2661
- enum8 = 27;
2662
- break;
2663
- }
2664
- case 'no-tty': {
2665
- enum8 = 28;
2666
- break;
2667
- }
2668
- case 'no-such-device': {
2669
- enum8 = 29;
2670
- break;
2671
- }
2672
- case 'overflow': {
2673
- enum8 = 30;
2674
- break;
2675
- }
2676
- case 'not-permitted': {
2677
- enum8 = 31;
2678
- break;
2679
- }
2680
- case 'pipe': {
2681
- enum8 = 32;
2682
- break;
2683
- }
2684
- case 'read-only': {
2685
- enum8 = 33;
2686
- break;
2687
- }
2688
- case 'invalid-seek': {
2689
- enum8 = 34;
2690
- break;
2691
- }
2692
- case 'text-file-busy': {
2693
- enum8 = 35;
2694
- break;
2695
- }
2696
- case 'cross-device': {
2697
- enum8 = 36;
2698
- break;
2699
- }
2700
- default: {
2701
- if ((e) instanceof Error) {
2702
- console.error(e);
2703
- }
2704
-
2705
- throw new TypeError(`"${val8}" is not one of the cases of error-code`);
2706
- }
2707
- }
2708
- dataView(memory0).setInt8(arg6 + 4, enum8, true);
2709
- break;
2710
- }
2711
- default: {
2712
- throw new TypeError('invalid variant specified for result');
2713
- }
2714
- }
2715
- }
2716
-
2717
-
2718
- function trampoline23(arg0, arg1) {
2719
- var handle1 = arg0;
2720
- var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
2721
- var rsc0 = captureTable6.get(rep2);
2722
- if (!rsc0) {
2723
- rsc0 = Object.create(DirectoryEntryStream.prototype);
2724
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
2725
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
2726
- }
2727
- curResourceBorrows.push(rsc0);
2728
- let ret;
2729
- try {
2730
- ret = { tag: 'ok', val: rsc0.readDirectoryEntry()};
2731
- } catch (e) {
2732
- ret = { tag: 'err', val: getErrorPayload(e) };
2733
- }
2734
- for (const rsc of curResourceBorrows) {
2735
- rsc[symbolRscHandle] = undefined;
2736
- }
2737
- curResourceBorrows = [];
2738
- var variant8 = ret;
2739
- switch (variant8.tag) {
2740
- case 'ok': {
2741
- const e = variant8.val;
2742
- dataView(memory0).setInt8(arg1 + 0, 0, true);
2743
- var variant6 = e;
2744
- if (variant6 === null || variant6=== undefined) {
2745
- dataView(memory0).setInt8(arg1 + 4, 0, true);
2746
- } else {
2747
- const e = variant6;
2748
- dataView(memory0).setInt8(arg1 + 4, 1, true);
2749
- var {type: v3_0, name: v3_1 } = e;
2750
- var val4 = v3_0;
2751
- let enum4;
2752
- switch (val4) {
2753
- case 'unknown': {
2754
- enum4 = 0;
2755
- break;
2756
- }
2757
- case 'block-device': {
2758
- enum4 = 1;
2759
- break;
2760
- }
2761
- case 'character-device': {
2762
- enum4 = 2;
2763
- break;
2764
- }
2765
- case 'directory': {
2766
- enum4 = 3;
2767
- break;
2768
- }
2769
- case 'fifo': {
2770
- enum4 = 4;
2771
- break;
2772
- }
2773
- case 'symbolic-link': {
2774
- enum4 = 5;
2775
- break;
2776
- }
2777
- case 'regular-file': {
2778
- enum4 = 6;
2779
- break;
2780
- }
2781
- case 'socket': {
2782
- enum4 = 7;
2783
- break;
2784
- }
2785
- default: {
2786
- if ((v3_0) instanceof Error) {
2787
- console.error(v3_0);
2788
- }
2789
-
2790
- throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
2791
- }
2792
- }
2793
- dataView(memory0).setInt8(arg1 + 8, enum4, true);
2794
- var ptr5 = utf8Encode(v3_1, realloc0, memory0);
2795
- var len5 = utf8EncodedLen;
2796
- dataView(memory0).setInt32(arg1 + 16, len5, true);
2797
- dataView(memory0).setInt32(arg1 + 12, ptr5, true);
2798
- }
2799
- break;
2800
- }
2801
- case 'err': {
2802
- const e = variant8.val;
2803
- dataView(memory0).setInt8(arg1 + 0, 1, true);
2804
- var val7 = e;
2805
- let enum7;
2806
- switch (val7) {
2807
- case 'access': {
2808
- enum7 = 0;
2809
- break;
2810
- }
2811
- case 'would-block': {
2812
- enum7 = 1;
2813
- break;
2814
- }
2815
- case 'already': {
2816
- enum7 = 2;
2817
- break;
2818
- }
2819
- case 'bad-descriptor': {
2820
- enum7 = 3;
2821
- break;
2822
- }
2823
- case 'busy': {
2824
- enum7 = 4;
2825
- break;
2826
- }
2827
- case 'deadlock': {
2828
- enum7 = 5;
2829
- break;
2830
- }
2831
- case 'quota': {
2832
- enum7 = 6;
2833
- break;
2834
- }
2835
- case 'exist': {
2836
- enum7 = 7;
2837
- break;
2838
- }
2839
- case 'file-too-large': {
2840
- enum7 = 8;
2841
- break;
2842
- }
2843
- case 'illegal-byte-sequence': {
2844
- enum7 = 9;
2845
- break;
2846
- }
2847
- case 'in-progress': {
2848
- enum7 = 10;
2849
- break;
2850
- }
2851
- case 'interrupted': {
2852
- enum7 = 11;
2853
- break;
2854
- }
2855
- case 'invalid': {
2856
- enum7 = 12;
2857
- break;
2858
- }
2859
- case 'io': {
2860
- enum7 = 13;
2861
- break;
2862
- }
2863
- case 'is-directory': {
2864
- enum7 = 14;
2865
- break;
2866
- }
2867
- case 'loop': {
2868
- enum7 = 15;
2869
- break;
2870
- }
2871
- case 'too-many-links': {
2872
- enum7 = 16;
2873
- break;
2874
- }
2875
- case 'message-size': {
2876
- enum7 = 17;
2877
- break;
2878
- }
2879
- case 'name-too-long': {
2880
- enum7 = 18;
2881
- break;
2882
- }
2883
- case 'no-device': {
2884
- enum7 = 19;
2885
- break;
2886
- }
2887
- case 'no-entry': {
2888
- enum7 = 20;
2889
- break;
2890
- }
2891
- case 'no-lock': {
2892
- enum7 = 21;
2893
- break;
2894
- }
2895
- case 'insufficient-memory': {
2896
- enum7 = 22;
2897
- break;
2898
- }
2899
- case 'insufficient-space': {
2900
- enum7 = 23;
2901
- break;
2902
- }
2903
- case 'not-directory': {
2904
- enum7 = 24;
2905
- break;
2906
- }
2907
- case 'not-empty': {
2908
- enum7 = 25;
2909
- break;
2910
- }
2911
- case 'not-recoverable': {
2912
- enum7 = 26;
2913
- break;
2914
- }
2915
- case 'unsupported': {
2916
- enum7 = 27;
2917
- break;
2918
- }
2919
- case 'no-tty': {
2920
- enum7 = 28;
2921
- break;
2922
- }
2923
- case 'no-such-device': {
2924
- enum7 = 29;
2925
- break;
2926
- }
2927
- case 'overflow': {
2928
- enum7 = 30;
2929
- break;
2930
- }
2931
- case 'not-permitted': {
2932
- enum7 = 31;
2933
- break;
2934
- }
2935
- case 'pipe': {
2936
- enum7 = 32;
2937
- break;
2938
- }
2939
- case 'read-only': {
2940
- enum7 = 33;
2941
- break;
2942
- }
2943
- case 'invalid-seek': {
2944
- enum7 = 34;
2945
- break;
2946
- }
2947
- case 'text-file-busy': {
2948
- enum7 = 35;
2949
- break;
2950
- }
2951
- case 'cross-device': {
2952
- enum7 = 36;
2953
- break;
2954
- }
2955
- default: {
2956
- if ((e) instanceof Error) {
2957
- console.error(e);
2958
- }
2959
-
2960
- throw new TypeError(`"${val7}" is not one of the cases of error-code`);
2961
- }
2962
- }
2963
- dataView(memory0).setInt8(arg1 + 4, enum7, true);
2964
- break;
2965
- }
2966
- default: {
2967
- throw new TypeError('invalid variant specified for result');
2968
- }
2969
- }
2970
- }
2971
-
2972
-
2973
- function trampoline24(arg0, arg1, arg2) {
2974
- var handle1 = arg0;
2975
- var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
2976
- var rsc0 = captureTable1.get(rep2);
2977
- if (!rsc0) {
2978
- rsc0 = Object.create(InputStream.prototype);
2979
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
2980
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
2981
- }
2982
- curResourceBorrows.push(rsc0);
2983
- let ret;
2984
- try {
2985
- ret = { tag: 'ok', val: rsc0.read(BigInt.asUintN(64, arg1))};
2986
- } catch (e) {
2987
- ret = { tag: 'err', val: getErrorPayload(e) };
2988
- }
2989
- for (const rsc of curResourceBorrows) {
2990
- rsc[symbolRscHandle] = undefined;
2991
- }
2992
- curResourceBorrows = [];
2993
- var variant6 = ret;
2994
- switch (variant6.tag) {
2995
- case 'ok': {
2996
- const e = variant6.val;
2997
- dataView(memory0).setInt8(arg2 + 0, 0, true);
2998
- var val3 = e;
2999
- var len3 = val3.byteLength;
3000
- var ptr3 = realloc0(0, 0, 1, len3 * 1);
3001
- var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
3002
- (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
3003
- dataView(memory0).setInt32(arg2 + 8, len3, true);
3004
- dataView(memory0).setInt32(arg2 + 4, ptr3, true);
3005
- break;
3006
- }
3007
- case 'err': {
3008
- const e = variant6.val;
3009
- dataView(memory0).setInt8(arg2 + 0, 1, true);
3010
- var variant5 = e;
3011
- switch (variant5.tag) {
3012
- case 'last-operation-failed': {
3013
- const e = variant5.val;
3014
- dataView(memory0).setInt8(arg2 + 4, 0, true);
3015
- if (!(e instanceof Error$1)) {
3016
- throw new TypeError('Resource error: Not a valid "Error" resource.');
3017
- }
3018
- var handle4 = e[symbolRscHandle];
3019
- if (!handle4) {
3020
- const rep = e[symbolRscRep] || ++captureCnt0;
3021
- captureTable0.set(rep, e);
3022
- handle4 = rscTableCreateOwn(handleTable0, rep);
3023
- }
3024
- dataView(memory0).setInt32(arg2 + 8, handle4, true);
3025
- break;
3026
- }
3027
- case 'closed': {
3028
- dataView(memory0).setInt8(arg2 + 4, 1, true);
3029
- break;
3030
- }
3031
- default: {
3032
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
3033
- }
3034
- }
3035
- break;
3036
- }
3037
- default: {
3038
- throw new TypeError('invalid variant specified for result');
3039
- }
3040
- }
3041
- }
3042
-
3043
-
3044
- function trampoline25(arg0, arg1, arg2) {
3045
- var handle1 = arg0;
3046
- var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
3047
- var rsc0 = captureTable1.get(rep2);
3048
- if (!rsc0) {
3049
- rsc0 = Object.create(InputStream.prototype);
3050
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
3051
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
3052
- }
3053
- curResourceBorrows.push(rsc0);
3054
- let ret;
3055
- try {
3056
- ret = { tag: 'ok', val: rsc0.blockingRead(BigInt.asUintN(64, arg1))};
3057
- } catch (e) {
3058
- ret = { tag: 'err', val: getErrorPayload(e) };
3059
- }
3060
- for (const rsc of curResourceBorrows) {
3061
- rsc[symbolRscHandle] = undefined;
3062
- }
3063
- curResourceBorrows = [];
3064
- var variant6 = ret;
3065
- switch (variant6.tag) {
3066
- case 'ok': {
3067
- const e = variant6.val;
3068
- dataView(memory0).setInt8(arg2 + 0, 0, true);
3069
- var val3 = e;
3070
- var len3 = val3.byteLength;
3071
- var ptr3 = realloc0(0, 0, 1, len3 * 1);
3072
- var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
3073
- (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
3074
- dataView(memory0).setInt32(arg2 + 8, len3, true);
3075
- dataView(memory0).setInt32(arg2 + 4, ptr3, true);
3076
- break;
3077
- }
3078
- case 'err': {
3079
- const e = variant6.val;
3080
- dataView(memory0).setInt8(arg2 + 0, 1, true);
3081
- var variant5 = e;
3082
- switch (variant5.tag) {
3083
- case 'last-operation-failed': {
3084
- const e = variant5.val;
3085
- dataView(memory0).setInt8(arg2 + 4, 0, true);
3086
- if (!(e instanceof Error$1)) {
3087
- throw new TypeError('Resource error: Not a valid "Error" resource.');
3088
- }
3089
- var handle4 = e[symbolRscHandle];
3090
- if (!handle4) {
3091
- const rep = e[symbolRscRep] || ++captureCnt0;
3092
- captureTable0.set(rep, e);
3093
- handle4 = rscTableCreateOwn(handleTable0, rep);
3094
- }
3095
- dataView(memory0).setInt32(arg2 + 8, handle4, true);
3096
- break;
3097
- }
3098
- case 'closed': {
3099
- dataView(memory0).setInt8(arg2 + 4, 1, true);
3100
- break;
3101
- }
3102
- default: {
3103
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
3104
- }
3105
- }
3106
- break;
3107
- }
3108
- default: {
3109
- throw new TypeError('invalid variant specified for result');
3110
- }
3111
- }
3112
- }
3113
-
3114
-
3115
- function trampoline26(arg0, arg1) {
3116
- var handle1 = arg0;
3117
- var rep2 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
3118
- var rsc0 = captureTable2.get(rep2);
3119
- if (!rsc0) {
3120
- rsc0 = Object.create(OutputStream.prototype);
3121
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
3122
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
3123
- }
3124
- curResourceBorrows.push(rsc0);
3125
- let ret;
3126
- try {
3127
- ret = { tag: 'ok', val: rsc0.checkWrite()};
3128
- } catch (e) {
3129
- ret = { tag: 'err', val: getErrorPayload(e) };
3130
- }
3131
- for (const rsc of curResourceBorrows) {
3132
- rsc[symbolRscHandle] = undefined;
3133
- }
3134
- curResourceBorrows = [];
3135
- var variant5 = ret;
3136
- switch (variant5.tag) {
3137
- case 'ok': {
3138
- const e = variant5.val;
3139
- dataView(memory0).setInt8(arg1 + 0, 0, true);
3140
- dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
3141
- break;
3142
- }
3143
- case 'err': {
3144
- const e = variant5.val;
3145
- dataView(memory0).setInt8(arg1 + 0, 1, true);
3146
- var variant4 = e;
3147
- switch (variant4.tag) {
3148
- case 'last-operation-failed': {
3149
- const e = variant4.val;
3150
- dataView(memory0).setInt8(arg1 + 8, 0, true);
3151
- if (!(e instanceof Error$1)) {
3152
- throw new TypeError('Resource error: Not a valid "Error" resource.');
3153
- }
3154
- var handle3 = e[symbolRscHandle];
3155
- if (!handle3) {
3156
- const rep = e[symbolRscRep] || ++captureCnt0;
3157
- captureTable0.set(rep, e);
3158
- handle3 = rscTableCreateOwn(handleTable0, rep);
3159
- }
3160
- dataView(memory0).setInt32(arg1 + 12, handle3, true);
3161
- break;
3162
- }
3163
- case 'closed': {
3164
- dataView(memory0).setInt8(arg1 + 8, 1, true);
3165
- break;
3166
- }
3167
- default: {
3168
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
3169
- }
3170
- }
3171
- break;
3172
- }
3173
- default: {
3174
- throw new TypeError('invalid variant specified for result');
3175
- }
3176
- }
3177
- }
3178
-
3179
-
3180
- function trampoline27(arg0, arg1, arg2, arg3) {
3181
- var handle1 = arg0;
3182
- var rep2 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
3183
- var rsc0 = captureTable2.get(rep2);
3184
- if (!rsc0) {
3185
- rsc0 = Object.create(OutputStream.prototype);
3186
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
3187
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
3188
- }
3189
- curResourceBorrows.push(rsc0);
3190
- var ptr3 = arg1;
3191
- var len3 = arg2;
3192
- var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
3193
- let ret;
3194
- try {
3195
- ret = { tag: 'ok', val: rsc0.write(result3)};
3196
- } catch (e) {
3197
- ret = { tag: 'err', val: getErrorPayload(e) };
3198
- }
3199
- for (const rsc of curResourceBorrows) {
3200
- rsc[symbolRscHandle] = undefined;
3201
- }
3202
- curResourceBorrows = [];
3203
- var variant6 = ret;
3204
- switch (variant6.tag) {
3205
- case 'ok': {
3206
- const e = variant6.val;
3207
- dataView(memory0).setInt8(arg3 + 0, 0, true);
3208
- break;
3209
- }
3210
- case 'err': {
3211
- const e = variant6.val;
3212
- dataView(memory0).setInt8(arg3 + 0, 1, true);
3213
- var variant5 = e;
3214
- switch (variant5.tag) {
3215
- case 'last-operation-failed': {
3216
- const e = variant5.val;
3217
- dataView(memory0).setInt8(arg3 + 4, 0, true);
3218
- if (!(e instanceof Error$1)) {
3219
- throw new TypeError('Resource error: Not a valid "Error" resource.');
3220
- }
3221
- var handle4 = e[symbolRscHandle];
3222
- if (!handle4) {
3223
- const rep = e[symbolRscRep] || ++captureCnt0;
3224
- captureTable0.set(rep, e);
3225
- handle4 = rscTableCreateOwn(handleTable0, rep);
3226
- }
3227
- dataView(memory0).setInt32(arg3 + 8, handle4, true);
3228
- break;
3229
- }
3230
- case 'closed': {
3231
- dataView(memory0).setInt8(arg3 + 4, 1, true);
3232
- break;
3233
- }
3234
- default: {
3235
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
3236
- }
3237
- }
3238
- break;
3239
- }
3240
- default: {
3241
- throw new TypeError('invalid variant specified for result');
3242
- }
3243
- }
3244
- }
3245
-
3246
-
3247
- function trampoline28(arg0, arg1, arg2, arg3) {
3248
- var handle1 = arg0;
3249
- var rep2 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
3250
- var rsc0 = captureTable2.get(rep2);
3251
- if (!rsc0) {
3252
- rsc0 = Object.create(OutputStream.prototype);
3253
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
3254
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
3255
- }
3256
- curResourceBorrows.push(rsc0);
3257
- var ptr3 = arg1;
3258
- var len3 = arg2;
3259
- var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
3260
- let ret;
3261
- try {
3262
- ret = { tag: 'ok', val: rsc0.blockingWriteAndFlush(result3)};
3263
- } catch (e) {
3264
- ret = { tag: 'err', val: getErrorPayload(e) };
3265
- }
3266
- for (const rsc of curResourceBorrows) {
3267
- rsc[symbolRscHandle] = undefined;
3268
- }
3269
- curResourceBorrows = [];
3270
- var variant6 = ret;
3271
- switch (variant6.tag) {
3272
- case 'ok': {
3273
- const e = variant6.val;
3274
- dataView(memory0).setInt8(arg3 + 0, 0, true);
3275
- break;
3276
- }
3277
- case 'err': {
3278
- const e = variant6.val;
3279
- dataView(memory0).setInt8(arg3 + 0, 1, true);
3280
- var variant5 = e;
3281
- switch (variant5.tag) {
3282
- case 'last-operation-failed': {
3283
- const e = variant5.val;
3284
- dataView(memory0).setInt8(arg3 + 4, 0, true);
3285
- if (!(e instanceof Error$1)) {
3286
- throw new TypeError('Resource error: Not a valid "Error" resource.');
3287
- }
3288
- var handle4 = e[symbolRscHandle];
3289
- if (!handle4) {
3290
- const rep = e[symbolRscRep] || ++captureCnt0;
3291
- captureTable0.set(rep, e);
3292
- handle4 = rscTableCreateOwn(handleTable0, rep);
3293
- }
3294
- dataView(memory0).setInt32(arg3 + 8, handle4, true);
3295
- break;
3296
- }
3297
- case 'closed': {
3298
- dataView(memory0).setInt8(arg3 + 4, 1, true);
3299
- break;
3300
- }
3301
- default: {
3302
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
3303
- }
3304
- }
3305
- break;
3306
- }
3307
- default: {
3308
- throw new TypeError('invalid variant specified for result');
3309
- }
3310
- }
3311
- }
3312
-
3313
-
3314
- function trampoline29(arg0, arg1) {
3315
- var handle1 = arg0;
3316
- var rep2 = handleTable2[(handle1 << 1) + 1] & ~T_FLAG;
3317
- var rsc0 = captureTable2.get(rep2);
3318
- if (!rsc0) {
3319
- rsc0 = Object.create(OutputStream.prototype);
3320
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
3321
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
3322
- }
3323
- curResourceBorrows.push(rsc0);
3324
- let ret;
3325
- try {
3326
- ret = { tag: 'ok', val: rsc0.blockingFlush()};
3327
- } catch (e) {
3328
- ret = { tag: 'err', val: getErrorPayload(e) };
3329
- }
3330
- for (const rsc of curResourceBorrows) {
3331
- rsc[symbolRscHandle] = undefined;
3332
- }
3333
- curResourceBorrows = [];
3334
- var variant5 = ret;
3335
- switch (variant5.tag) {
3336
- case 'ok': {
3337
- const e = variant5.val;
3338
- dataView(memory0).setInt8(arg1 + 0, 0, true);
3339
- break;
3340
- }
3341
- case 'err': {
3342
- const e = variant5.val;
3343
- dataView(memory0).setInt8(arg1 + 0, 1, true);
3344
- var variant4 = e;
3345
- switch (variant4.tag) {
3346
- case 'last-operation-failed': {
3347
- const e = variant4.val;
3348
- dataView(memory0).setInt8(arg1 + 4, 0, true);
3349
- if (!(e instanceof Error$1)) {
3350
- throw new TypeError('Resource error: Not a valid "Error" resource.');
3351
- }
3352
- var handle3 = e[symbolRscHandle];
3353
- if (!handle3) {
3354
- const rep = e[symbolRscRep] || ++captureCnt0;
3355
- captureTable0.set(rep, e);
3356
- handle3 = rscTableCreateOwn(handleTable0, rep);
3357
- }
3358
- dataView(memory0).setInt32(arg1 + 8, handle3, true);
3359
- break;
3360
- }
3361
- case 'closed': {
3362
- dataView(memory0).setInt8(arg1 + 4, 1, true);
3363
- break;
3364
- }
3365
- default: {
3366
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
3367
- }
3368
- }
3369
- break;
3370
- }
3371
- default: {
3372
- throw new TypeError('invalid variant specified for result');
3373
- }
3374
- }
3375
- }
3376
-
3377
-
3378
- function trampoline30(arg0, arg1) {
3379
- const ret = getRandomBytes(BigInt.asUintN(64, arg0));
3380
- var val0 = ret;
3381
- var len0 = val0.byteLength;
3382
- var ptr0 = realloc0(0, 0, 1, len0 * 1);
3383
- var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
3384
- (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
3385
- dataView(memory0).setInt32(arg1 + 4, len0, true);
3386
- dataView(memory0).setInt32(arg1 + 0, ptr0, true);
3387
- }
3388
-
3389
-
3390
- function trampoline31(arg0) {
3391
- const ret = getDirectories();
3392
- var vec3 = ret;
3393
- var len3 = vec3.length;
3394
- var result3 = realloc0(0, 0, 4, len3 * 12);
3395
- for (let i = 0; i < vec3.length; i++) {
3396
- const e = vec3[i];
3397
- const base = result3 + i * 12;var [tuple0_0, tuple0_1] = e;
3398
- if (!(tuple0_0 instanceof Descriptor)) {
3399
- throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
3400
- }
3401
- var handle1 = tuple0_0[symbolRscHandle];
3402
- if (!handle1) {
3403
- const rep = tuple0_0[symbolRscRep] || ++captureCnt5;
3404
- captureTable5.set(rep, tuple0_0);
3405
- handle1 = rscTableCreateOwn(handleTable5, rep);
3406
- }
3407
- dataView(memory0).setInt32(base + 0, handle1, true);
3408
- var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
3409
- var len2 = utf8EncodedLen;
3410
- dataView(memory0).setInt32(base + 8, len2, true);
3411
- dataView(memory0).setInt32(base + 4, ptr2, true);
3412
- }
3413
- dataView(memory0).setInt32(arg0 + 4, len3, true);
3414
- dataView(memory0).setInt32(arg0 + 0, result3, true);
3415
- }
3416
-
3417
- const handleTable3 = [T_FLAG, 0];
3418
- const captureTable3= new Map();
3419
- let captureCnt3 = 0;
3420
- handleTables[3] = handleTable3;
3421
-
3422
- function trampoline32(arg0) {
3423
- const ret = getTerminalStdin();
3424
- var variant1 = ret;
3425
- if (variant1 === null || variant1=== undefined) {
3426
- dataView(memory0).setInt8(arg0 + 0, 0, true);
3427
- } else {
3428
- const e = variant1;
3429
- dataView(memory0).setInt8(arg0 + 0, 1, true);
3430
- if (!(e instanceof TerminalInput)) {
3431
- throw new TypeError('Resource error: Not a valid "TerminalInput" resource.');
3432
- }
3433
- var handle0 = e[symbolRscHandle];
3434
- if (!handle0) {
3435
- const rep = e[symbolRscRep] || ++captureCnt3;
3436
- captureTable3.set(rep, e);
3437
- handle0 = rscTableCreateOwn(handleTable3, rep);
3438
- }
3439
- dataView(memory0).setInt32(arg0 + 4, handle0, true);
3440
- }
3441
- }
3442
-
3443
- const handleTable4 = [T_FLAG, 0];
3444
- const captureTable4= new Map();
3445
- let captureCnt4 = 0;
3446
- handleTables[4] = handleTable4;
3447
-
3448
- function trampoline33(arg0) {
3449
- const ret = getTerminalStdout();
3450
- var variant1 = ret;
3451
- if (variant1 === null || variant1=== undefined) {
3452
- dataView(memory0).setInt8(arg0 + 0, 0, true);
3453
- } else {
3454
- const e = variant1;
3455
- dataView(memory0).setInt8(arg0 + 0, 1, true);
3456
- if (!(e instanceof TerminalOutput)) {
3457
- throw new TypeError('Resource error: Not a valid "TerminalOutput" resource.');
3458
- }
3459
- var handle0 = e[symbolRscHandle];
3460
- if (!handle0) {
3461
- const rep = e[symbolRscRep] || ++captureCnt4;
3462
- captureTable4.set(rep, e);
3463
- handle0 = rscTableCreateOwn(handleTable4, rep);
3464
- }
3465
- dataView(memory0).setInt32(arg0 + 4, handle0, true);
3466
- }
3467
- }
3468
-
3469
-
3470
- function trampoline34(arg0) {
3471
- const ret = getTerminalStderr();
3472
- var variant1 = ret;
3473
- if (variant1 === null || variant1=== undefined) {
3474
- dataView(memory0).setInt8(arg0 + 0, 0, true);
3475
- } else {
3476
- const e = variant1;
3477
- dataView(memory0).setInt8(arg0 + 0, 1, true);
3478
- if (!(e instanceof TerminalOutput)) {
3479
- throw new TypeError('Resource error: Not a valid "TerminalOutput" resource.');
3480
- }
3481
- var handle0 = e[symbolRscHandle];
3482
- if (!handle0) {
3483
- const rep = e[symbolRscRep] || ++captureCnt4;
3484
- captureTable4.set(rep, e);
3485
- handle0 = rscTableCreateOwn(handleTable4, rep);
3486
- }
3487
- dataView(memory0).setInt32(arg0 + 4, handle0, true);
3488
- }
3489
- }
3490
-
3491
- let exports3;
3492
- let realloc1;
3493
- let postReturn0;
3494
- let postReturn1;
3495
- function trampoline0(handle) {
3496
- const handleEntry = rscTableRemove(handleTable6, handle);
3497
- if (handleEntry.own) {
3498
-
3499
- const rsc = captureTable6.get(handleEntry.rep);
3500
- if (rsc) {
3501
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3502
- captureTable6.delete(handleEntry.rep);
3503
- } else if (DirectoryEntryStream[symbolCabiDispose]) {
3504
- DirectoryEntryStream[symbolCabiDispose](handleEntry.rep);
3505
- }
3506
- }
3507
- }
3508
- function trampoline1(handle) {
3509
- const handleEntry = rscTableRemove(handleTable2, handle);
3510
- if (handleEntry.own) {
3511
-
3512
- const rsc = captureTable2.get(handleEntry.rep);
3513
- if (rsc) {
3514
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3515
- captureTable2.delete(handleEntry.rep);
3516
- } else if (OutputStream[symbolCabiDispose]) {
3517
- OutputStream[symbolCabiDispose](handleEntry.rep);
3518
- }
3519
- }
3520
- }
3521
- function trampoline2(handle) {
3522
- const handleEntry = rscTableRemove(handleTable0, handle);
3523
- if (handleEntry.own) {
3524
-
3525
- const rsc = captureTable0.get(handleEntry.rep);
3526
- if (rsc) {
3527
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3528
- captureTable0.delete(handleEntry.rep);
3529
- } else if (Error$1[symbolCabiDispose]) {
3530
- Error$1[symbolCabiDispose](handleEntry.rep);
3531
- }
3532
- }
3533
- }
3534
- function trampoline3(handle) {
3535
- const handleEntry = rscTableRemove(handleTable1, handle);
3536
- if (handleEntry.own) {
3537
-
3538
- const rsc = captureTable1.get(handleEntry.rep);
3539
- if (rsc) {
3540
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3541
- captureTable1.delete(handleEntry.rep);
3542
- } else if (InputStream[symbolCabiDispose]) {
3543
- InputStream[symbolCabiDispose](handleEntry.rep);
3544
- }
3545
- }
3546
- }
3547
- function trampoline4(handle) {
3548
- const handleEntry = rscTableRemove(handleTable5, handle);
3549
- if (handleEntry.own) {
3550
-
3551
- const rsc = captureTable5.get(handleEntry.rep);
3552
- if (rsc) {
3553
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3554
- captureTable5.delete(handleEntry.rep);
3555
- } else if (Descriptor[symbolCabiDispose]) {
3556
- Descriptor[symbolCabiDispose](handleEntry.rep);
3557
- }
3558
- }
3559
- }
3560
- function trampoline6(handle) {
3561
- const handleEntry = rscTableRemove(handleTable3, handle);
3562
- if (handleEntry.own) {
3563
-
3564
- const rsc = captureTable3.get(handleEntry.rep);
3565
- if (rsc) {
3566
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3567
- captureTable3.delete(handleEntry.rep);
3568
- } else if (TerminalInput[symbolCabiDispose]) {
3569
- TerminalInput[symbolCabiDispose](handleEntry.rep);
3570
- }
3571
- }
3572
- }
3573
- function trampoline7(handle) {
3574
- const handleEntry = rscTableRemove(handleTable4, handle);
3575
- if (handleEntry.own) {
3576
-
3577
- const rsc = captureTable4.get(handleEntry.rep);
3578
- if (rsc) {
3579
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3580
- captureTable4.delete(handleEntry.rep);
3581
- } else if (TerminalOutput[symbolCabiDispose]) {
3582
- TerminalOutput[symbolCabiDispose](handleEntry.rep);
3583
- }
3584
- }
3585
- }
3586
- let exports1Generate;
3587
-
3588
- function generate(arg0, arg1) {
3589
- if (!_initialized) throwUninitialized();
3590
- var ptr0 = realloc1(0, 0, 4, 84);
3591
- var val1 = arg0;
3592
- var len1 = val1.byteLength;
3593
- var ptr1 = realloc1(0, 0, 1, len1 * 1);
3594
- var src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
3595
- (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
3596
- dataView(memory0).setInt32(ptr0 + 4, len1, true);
3597
- dataView(memory0).setInt32(ptr0 + 0, ptr1, true);
3598
- var {name: v2_0, noTypescript: v2_1, instantiation: v2_2, importBindings: v2_3, map: v2_4, compat: v2_5, noNodejsCompat: v2_6, base64Cutoff: v2_7, tlaCompat: v2_8, validLiftingOptimization: v2_9, tracing: v2_10, noNamespacedExports: v2_11, guest: v2_12, multiMemory: v2_13, asyncMode: v2_14 } = arg1;
3599
- var ptr3 = utf8Encode(v2_0, realloc1, memory0);
3600
- var len3 = utf8EncodedLen;
3601
- dataView(memory0).setInt32(ptr0 + 12, len3, true);
3602
- dataView(memory0).setInt32(ptr0 + 8, ptr3, true);
3603
- var variant4 = v2_1;
3604
- if (variant4 === null || variant4=== undefined) {
3605
- dataView(memory0).setInt8(ptr0 + 16, 0, true);
3606
- } else {
3607
- const e = variant4;
3608
- dataView(memory0).setInt8(ptr0 + 16, 1, true);
3609
- dataView(memory0).setInt8(ptr0 + 17, e ? 1 : 0, true);
3610
- }
3611
- var variant6 = v2_2;
3612
- if (variant6 === null || variant6=== undefined) {
3613
- dataView(memory0).setInt8(ptr0 + 18, 0, true);
3614
- } else {
3615
- const e = variant6;
3616
- dataView(memory0).setInt8(ptr0 + 18, 1, true);
3617
- var variant5 = e;
3618
- switch (variant5.tag) {
3619
- case 'async': {
3620
- dataView(memory0).setInt8(ptr0 + 19, 0, true);
3621
- break;
3622
- }
3623
- case 'sync': {
3624
- dataView(memory0).setInt8(ptr0 + 19, 1, true);
3625
- break;
3626
- }
3627
- default: {
3628
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`InstantiationMode\``);
3629
- }
3630
- }
3631
- }
3632
- var variant8 = v2_3;
3633
- if (variant8 === null || variant8=== undefined) {
3634
- dataView(memory0).setInt8(ptr0 + 20, 0, true);
3635
- } else {
3636
- const e = variant8;
3637
- dataView(memory0).setInt8(ptr0 + 20, 1, true);
3638
- var variant7 = e;
3639
- switch (variant7.tag) {
3640
- case 'js': {
3641
- dataView(memory0).setInt8(ptr0 + 21, 0, true);
3642
- break;
3643
- }
3644
- case 'hybrid': {
3645
- dataView(memory0).setInt8(ptr0 + 21, 1, true);
3646
- break;
3647
- }
3648
- case 'optimized': {
3649
- dataView(memory0).setInt8(ptr0 + 21, 2, true);
3650
- break;
3651
- }
3652
- case 'direct-optimized': {
3653
- dataView(memory0).setInt8(ptr0 + 21, 3, true);
3654
- break;
3655
- }
3656
- default: {
3657
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant7.tag)}\` (received \`${variant7}\`) specified for \`BindingsMode\``);
3658
- }
3659
- }
3660
- }
3661
- var variant13 = v2_4;
3662
- if (variant13 === null || variant13=== undefined) {
3663
- dataView(memory0).setInt8(ptr0 + 24, 0, true);
3664
- } else {
3665
- const e = variant13;
3666
- dataView(memory0).setInt8(ptr0 + 24, 1, true);
3667
- var vec12 = e;
3668
- var len12 = vec12.length;
3669
- var result12 = realloc1(0, 0, 4, len12 * 16);
3670
- for (let i = 0; i < vec12.length; i++) {
3671
- const e = vec12[i];
3672
- const base = result12 + i * 16;var [tuple9_0, tuple9_1] = e;
3673
- var ptr10 = utf8Encode(tuple9_0, realloc1, memory0);
3674
- var len10 = utf8EncodedLen;
3675
- dataView(memory0).setInt32(base + 4, len10, true);
3676
- dataView(memory0).setInt32(base + 0, ptr10, true);
3677
- var ptr11 = utf8Encode(tuple9_1, realloc1, memory0);
3678
- var len11 = utf8EncodedLen;
3679
- dataView(memory0).setInt32(base + 12, len11, true);
3680
- dataView(memory0).setInt32(base + 8, ptr11, true);
3681
- }
3682
- dataView(memory0).setInt32(ptr0 + 32, len12, true);
3683
- dataView(memory0).setInt32(ptr0 + 28, result12, true);
3684
- }
3685
- var variant14 = v2_5;
3686
- if (variant14 === null || variant14=== undefined) {
3687
- dataView(memory0).setInt8(ptr0 + 36, 0, true);
3688
- } else {
3689
- const e = variant14;
3690
- dataView(memory0).setInt8(ptr0 + 36, 1, true);
3691
- dataView(memory0).setInt8(ptr0 + 37, e ? 1 : 0, true);
3692
- }
3693
- var variant15 = v2_6;
3694
- if (variant15 === null || variant15=== undefined) {
3695
- dataView(memory0).setInt8(ptr0 + 38, 0, true);
3696
- } else {
3697
- const e = variant15;
3698
- dataView(memory0).setInt8(ptr0 + 38, 1, true);
3699
- dataView(memory0).setInt8(ptr0 + 39, e ? 1 : 0, true);
3700
- }
3701
- var variant16 = v2_7;
3702
- if (variant16 === null || variant16=== undefined) {
3703
- dataView(memory0).setInt8(ptr0 + 40, 0, true);
3704
- } else {
3705
- const e = variant16;
3706
- dataView(memory0).setInt8(ptr0 + 40, 1, true);
3707
- dataView(memory0).setInt32(ptr0 + 44, toUint32(e), true);
3708
- }
3709
- var variant17 = v2_8;
3710
- if (variant17 === null || variant17=== undefined) {
3711
- dataView(memory0).setInt8(ptr0 + 48, 0, true);
3712
- } else {
3713
- const e = variant17;
3714
- dataView(memory0).setInt8(ptr0 + 48, 1, true);
3715
- dataView(memory0).setInt8(ptr0 + 49, e ? 1 : 0, true);
3716
- }
3717
- var variant18 = v2_9;
3718
- if (variant18 === null || variant18=== undefined) {
3719
- dataView(memory0).setInt8(ptr0 + 50, 0, true);
3720
- } else {
3721
- const e = variant18;
3722
- dataView(memory0).setInt8(ptr0 + 50, 1, true);
3723
- dataView(memory0).setInt8(ptr0 + 51, e ? 1 : 0, true);
3724
- }
3725
- var variant19 = v2_10;
3726
- if (variant19 === null || variant19=== undefined) {
3727
- dataView(memory0).setInt8(ptr0 + 52, 0, true);
3728
- } else {
3729
- const e = variant19;
3730
- dataView(memory0).setInt8(ptr0 + 52, 1, true);
3731
- dataView(memory0).setInt8(ptr0 + 53, e ? 1 : 0, true);
3732
- }
3733
- var variant20 = v2_11;
3734
- if (variant20 === null || variant20=== undefined) {
3735
- dataView(memory0).setInt8(ptr0 + 54, 0, true);
3736
- } else {
3737
- const e = variant20;
3738
- dataView(memory0).setInt8(ptr0 + 54, 1, true);
3739
- dataView(memory0).setInt8(ptr0 + 55, e ? 1 : 0, true);
3740
- }
3741
- var variant21 = v2_12;
3742
- if (variant21 === null || variant21=== undefined) {
3743
- dataView(memory0).setInt8(ptr0 + 56, 0, true);
3744
- } else {
3745
- const e = variant21;
3746
- dataView(memory0).setInt8(ptr0 + 56, 1, true);
3747
- dataView(memory0).setInt8(ptr0 + 57, e ? 1 : 0, true);
3748
- }
3749
- var variant22 = v2_13;
3750
- if (variant22 === null || variant22=== undefined) {
3751
- dataView(memory0).setInt8(ptr0 + 58, 0, true);
3752
- } else {
3753
- const e = variant22;
3754
- dataView(memory0).setInt8(ptr0 + 58, 1, true);
3755
- dataView(memory0).setInt8(ptr0 + 59, e ? 1 : 0, true);
3756
- }
3757
- var variant29 = v2_14;
3758
- if (variant29 === null || variant29=== undefined) {
3759
- dataView(memory0).setInt8(ptr0 + 60, 0, true);
3760
- } else {
3761
- const e = variant29;
3762
- dataView(memory0).setInt8(ptr0 + 60, 1, true);
3763
- var variant28 = e;
3764
- switch (variant28.tag) {
3765
- case 'sync': {
3766
- dataView(memory0).setInt8(ptr0 + 64, 0, true);
3767
- break;
3768
- }
3769
- case 'jspi': {
3770
- const e = variant28.val;
3771
- dataView(memory0).setInt8(ptr0 + 64, 1, true);
3772
- var {imports: v23_0, exports: v23_1 } = e;
3773
- var vec25 = v23_0;
3774
- var len25 = vec25.length;
3775
- var result25 = realloc1(0, 0, 4, len25 * 8);
3776
- for (let i = 0; i < vec25.length; i++) {
3777
- const e = vec25[i];
3778
- const base = result25 + i * 8;var ptr24 = utf8Encode(e, realloc1, memory0);
3779
- var len24 = utf8EncodedLen;
3780
- dataView(memory0).setInt32(base + 4, len24, true);
3781
- dataView(memory0).setInt32(base + 0, ptr24, true);
3782
- }
3783
- dataView(memory0).setInt32(ptr0 + 72, len25, true);
3784
- dataView(memory0).setInt32(ptr0 + 68, result25, true);
3785
- var vec27 = v23_1;
3786
- var len27 = vec27.length;
3787
- var result27 = realloc1(0, 0, 4, len27 * 8);
3788
- for (let i = 0; i < vec27.length; i++) {
3789
- const e = vec27[i];
3790
- const base = result27 + i * 8;var ptr26 = utf8Encode(e, realloc1, memory0);
3791
- var len26 = utf8EncodedLen;
3792
- dataView(memory0).setInt32(base + 4, len26, true);
3793
- dataView(memory0).setInt32(base + 0, ptr26, true);
3794
- }
3795
- dataView(memory0).setInt32(ptr0 + 80, len27, true);
3796
- dataView(memory0).setInt32(ptr0 + 76, result27, true);
3797
- break;
3798
- }
3799
- default: {
3800
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant28.tag)}\` (received \`${variant28}\`) specified for \`AsyncMode\``);
3801
- }
3802
- }
3803
- }
3804
- const ret = exports1Generate(ptr0);
3805
- let variant39;
3806
- switch (dataView(memory0).getUint8(ret + 0, true)) {
3807
- case 0: {
3808
- var len32 = dataView(memory0).getInt32(ret + 8, true);
3809
- var base32 = dataView(memory0).getInt32(ret + 4, true);
3810
- var result32 = [];
3811
- for (let i = 0; i < len32; i++) {
3812
- const base = base32 + i * 16;
3813
- var ptr30 = dataView(memory0).getInt32(base + 0, true);
3814
- var len30 = dataView(memory0).getInt32(base + 4, true);
3815
- var result30 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr30, len30));
3816
- var ptr31 = dataView(memory0).getInt32(base + 8, true);
3817
- var len31 = dataView(memory0).getInt32(base + 12, true);
3818
- var result31 = new Uint8Array(memory0.buffer.slice(ptr31, ptr31 + len31 * 1));
3819
- result32.push([result30, result31]);
3820
- }
3821
- var len34 = dataView(memory0).getInt32(ret + 16, true);
3822
- var base34 = dataView(memory0).getInt32(ret + 12, true);
3823
- var result34 = [];
3824
- for (let i = 0; i < len34; i++) {
3825
- const base = base34 + i * 8;
3826
- var ptr33 = dataView(memory0).getInt32(base + 0, true);
3827
- var len33 = dataView(memory0).getInt32(base + 4, true);
3828
- var result33 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr33, len33));
3829
- result34.push(result33);
3830
- }
3831
- var len37 = dataView(memory0).getInt32(ret + 24, true);
3832
- var base37 = dataView(memory0).getInt32(ret + 20, true);
3833
- var result37 = [];
3834
- for (let i = 0; i < len37; i++) {
3835
- const base = base37 + i * 12;
3836
- var ptr35 = dataView(memory0).getInt32(base + 0, true);
3837
- var len35 = dataView(memory0).getInt32(base + 4, true);
3838
- var result35 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr35, len35));
3839
- let enum36;
3840
- switch (dataView(memory0).getUint8(base + 8, true)) {
3841
- case 0: {
3842
- enum36 = 'function';
3843
- break;
3844
- }
3845
- case 1: {
3846
- enum36 = 'instance';
3847
- break;
3848
- }
3849
- default: {
3850
- throw new TypeError('invalid discriminant specified for ExportType');
3851
- }
3852
- }
3853
- result37.push([result35, enum36]);
3854
- }
3855
- variant39= {
3856
- tag: 'ok',
3857
- val: {
3858
- files: result32,
3859
- imports: result34,
3860
- exports: result37,
3861
- }
3862
- };
3863
- break;
3864
- }
3865
- case 1: {
3866
- var ptr38 = dataView(memory0).getInt32(ret + 4, true);
3867
- var len38 = dataView(memory0).getInt32(ret + 8, true);
3868
- var result38 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr38, len38));
3869
- variant39= {
3870
- tag: 'err',
3871
- val: result38
3872
- };
3873
- break;
3874
- }
3875
- default: {
3876
- throw new TypeError('invalid variant discriminant for expected');
3877
- }
3878
- }
3879
- const retVal = variant39;
3880
- postReturn0(ret);
3881
- if (typeof retVal === 'object' && retVal.tag === 'err') {
3882
- throw new ComponentError(retVal.val);
3883
- }
3884
- return retVal.val;
3885
- }
3886
- let exports1GenerateTypes;
3887
-
3888
- function generateTypes(arg0, arg1) {
3889
- if (!_initialized) throwUninitialized();
3890
- var ptr0 = realloc1(0, 0, 4, 92);
3891
- var ptr1 = utf8Encode(arg0, realloc1, memory0);
3892
- var len1 = utf8EncodedLen;
3893
- dataView(memory0).setInt32(ptr0 + 4, len1, true);
3894
- dataView(memory0).setInt32(ptr0 + 0, ptr1, true);
3895
- var {wit: v2_0, world: v2_1, tlaCompat: v2_2, instantiation: v2_3, map: v2_4, features: v2_5, guest: v2_6, asyncMode: v2_7 } = arg1;
3896
- var variant6 = v2_0;
3897
- switch (variant6.tag) {
3898
- case 'source': {
3899
- const e = variant6.val;
3900
- dataView(memory0).setInt8(ptr0 + 8, 0, true);
3901
- var ptr3 = utf8Encode(e, realloc1, memory0);
3902
- var len3 = utf8EncodedLen;
3903
- dataView(memory0).setInt32(ptr0 + 16, len3, true);
3904
- dataView(memory0).setInt32(ptr0 + 12, ptr3, true);
3905
- break;
3906
- }
3907
- case 'binary': {
3908
- const e = variant6.val;
3909
- dataView(memory0).setInt8(ptr0 + 8, 1, true);
3910
- var val4 = e;
3911
- var len4 = val4.byteLength;
3912
- var ptr4 = realloc1(0, 0, 1, len4 * 1);
3913
- var src4 = new Uint8Array(val4.buffer || val4, val4.byteOffset, len4 * 1);
3914
- (new Uint8Array(memory0.buffer, ptr4, len4 * 1)).set(src4);
3915
- dataView(memory0).setInt32(ptr0 + 16, len4, true);
3916
- dataView(memory0).setInt32(ptr0 + 12, ptr4, true);
3917
- break;
3918
- }
3919
- case 'path': {
3920
- const e = variant6.val;
3921
- dataView(memory0).setInt8(ptr0 + 8, 2, true);
3922
- var ptr5 = utf8Encode(e, realloc1, memory0);
3923
- var len5 = utf8EncodedLen;
3924
- dataView(memory0).setInt32(ptr0 + 16, len5, true);
3925
- dataView(memory0).setInt32(ptr0 + 12, ptr5, true);
3926
- break;
3927
- }
3928
- default: {
3929
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant6.tag)}\` (received \`${variant6}\`) specified for \`Wit\``);
3930
- }
3931
- }
3932
- var variant8 = v2_1;
3933
- if (variant8 === null || variant8=== undefined) {
3934
- dataView(memory0).setInt8(ptr0 + 20, 0, true);
3935
- } else {
3936
- const e = variant8;
3937
- dataView(memory0).setInt8(ptr0 + 20, 1, true);
3938
- var ptr7 = utf8Encode(e, realloc1, memory0);
3939
- var len7 = utf8EncodedLen;
3940
- dataView(memory0).setInt32(ptr0 + 28, len7, true);
3941
- dataView(memory0).setInt32(ptr0 + 24, ptr7, true);
3942
- }
3943
- var variant9 = v2_2;
3944
- if (variant9 === null || variant9=== undefined) {
3945
- dataView(memory0).setInt8(ptr0 + 32, 0, true);
3946
- } else {
3947
- const e = variant9;
3948
- dataView(memory0).setInt8(ptr0 + 32, 1, true);
3949
- dataView(memory0).setInt8(ptr0 + 33, e ? 1 : 0, true);
3950
- }
3951
- var variant11 = v2_3;
3952
- if (variant11 === null || variant11=== undefined) {
3953
- dataView(memory0).setInt8(ptr0 + 34, 0, true);
3954
- } else {
3955
- const e = variant11;
3956
- dataView(memory0).setInt8(ptr0 + 34, 1, true);
3957
- var variant10 = e;
3958
- switch (variant10.tag) {
3959
- case 'async': {
3960
- dataView(memory0).setInt8(ptr0 + 35, 0, true);
3961
- break;
3962
- }
3963
- case 'sync': {
3964
- dataView(memory0).setInt8(ptr0 + 35, 1, true);
3965
- break;
3966
- }
3967
- default: {
3968
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant10.tag)}\` (received \`${variant10}\`) specified for \`InstantiationMode\``);
3969
- }
3970
- }
3971
- }
3972
- var variant16 = v2_4;
3973
- if (variant16 === null || variant16=== undefined) {
3974
- dataView(memory0).setInt8(ptr0 + 36, 0, true);
3975
- } else {
3976
- const e = variant16;
3977
- dataView(memory0).setInt8(ptr0 + 36, 1, true);
3978
- var vec15 = e;
3979
- var len15 = vec15.length;
3980
- var result15 = realloc1(0, 0, 4, len15 * 16);
3981
- for (let i = 0; i < vec15.length; i++) {
3982
- const e = vec15[i];
3983
- const base = result15 + i * 16;var [tuple12_0, tuple12_1] = e;
3984
- var ptr13 = utf8Encode(tuple12_0, realloc1, memory0);
3985
- var len13 = utf8EncodedLen;
3986
- dataView(memory0).setInt32(base + 4, len13, true);
3987
- dataView(memory0).setInt32(base + 0, ptr13, true);
3988
- var ptr14 = utf8Encode(tuple12_1, realloc1, memory0);
3989
- var len14 = utf8EncodedLen;
3990
- dataView(memory0).setInt32(base + 12, len14, true);
3991
- dataView(memory0).setInt32(base + 8, ptr14, true);
3992
- }
3993
- dataView(memory0).setInt32(ptr0 + 44, len15, true);
3994
- dataView(memory0).setInt32(ptr0 + 40, result15, true);
3995
- }
3996
- var variant20 = v2_5;
3997
- if (variant20 === null || variant20=== undefined) {
3998
- dataView(memory0).setInt8(ptr0 + 48, 0, true);
3999
- } else {
4000
- const e = variant20;
4001
- dataView(memory0).setInt8(ptr0 + 48, 1, true);
4002
- var variant19 = e;
4003
- switch (variant19.tag) {
4004
- case 'list': {
4005
- const e = variant19.val;
4006
- dataView(memory0).setInt8(ptr0 + 52, 0, true);
4007
- var vec18 = e;
4008
- var len18 = vec18.length;
4009
- var result18 = realloc1(0, 0, 4, len18 * 8);
4010
- for (let i = 0; i < vec18.length; i++) {
4011
- const e = vec18[i];
4012
- const base = result18 + i * 8;var ptr17 = utf8Encode(e, realloc1, memory0);
4013
- var len17 = utf8EncodedLen;
4014
- dataView(memory0).setInt32(base + 4, len17, true);
4015
- dataView(memory0).setInt32(base + 0, ptr17, true);
4016
- }
4017
- dataView(memory0).setInt32(ptr0 + 60, len18, true);
4018
- dataView(memory0).setInt32(ptr0 + 56, result18, true);
4019
- break;
4020
- }
4021
- case 'all': {
4022
- dataView(memory0).setInt8(ptr0 + 52, 1, true);
4023
- break;
4024
- }
4025
- default: {
4026
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant19.tag)}\` (received \`${variant19}\`) specified for \`EnabledFeatureSet\``);
4027
- }
4028
- }
4029
- }
4030
- var variant21 = v2_6;
4031
- if (variant21 === null || variant21=== undefined) {
4032
- dataView(memory0).setInt8(ptr0 + 64, 0, true);
4033
- } else {
4034
- const e = variant21;
4035
- dataView(memory0).setInt8(ptr0 + 64, 1, true);
4036
- dataView(memory0).setInt8(ptr0 + 65, e ? 1 : 0, true);
4037
- }
4038
- var variant28 = v2_7;
4039
- if (variant28 === null || variant28=== undefined) {
4040
- dataView(memory0).setInt8(ptr0 + 68, 0, true);
4041
- } else {
4042
- const e = variant28;
4043
- dataView(memory0).setInt8(ptr0 + 68, 1, true);
4044
- var variant27 = e;
4045
- switch (variant27.tag) {
4046
- case 'sync': {
4047
- dataView(memory0).setInt8(ptr0 + 72, 0, true);
4048
- break;
4049
- }
4050
- case 'jspi': {
4051
- const e = variant27.val;
4052
- dataView(memory0).setInt8(ptr0 + 72, 1, true);
4053
- var {imports: v22_0, exports: v22_1 } = e;
4054
- var vec24 = v22_0;
4055
- var len24 = vec24.length;
4056
- var result24 = realloc1(0, 0, 4, len24 * 8);
4057
- for (let i = 0; i < vec24.length; i++) {
4058
- const e = vec24[i];
4059
- const base = result24 + i * 8;var ptr23 = utf8Encode(e, realloc1, memory0);
4060
- var len23 = utf8EncodedLen;
4061
- dataView(memory0).setInt32(base + 4, len23, true);
4062
- dataView(memory0).setInt32(base + 0, ptr23, true);
4063
- }
4064
- dataView(memory0).setInt32(ptr0 + 80, len24, true);
4065
- dataView(memory0).setInt32(ptr0 + 76, result24, true);
4066
- var vec26 = v22_1;
4067
- var len26 = vec26.length;
4068
- var result26 = realloc1(0, 0, 4, len26 * 8);
4069
- for (let i = 0; i < vec26.length; i++) {
4070
- const e = vec26[i];
4071
- const base = result26 + i * 8;var ptr25 = utf8Encode(e, realloc1, memory0);
4072
- var len25 = utf8EncodedLen;
4073
- dataView(memory0).setInt32(base + 4, len25, true);
4074
- dataView(memory0).setInt32(base + 0, ptr25, true);
4075
- }
4076
- dataView(memory0).setInt32(ptr0 + 88, len26, true);
4077
- dataView(memory0).setInt32(ptr0 + 84, result26, true);
4078
- break;
4079
- }
4080
- default: {
4081
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant27.tag)}\` (received \`${variant27}\`) specified for \`AsyncMode\``);
4082
- }
4083
- }
4084
- }
4085
- const ret = exports1GenerateTypes(ptr0);
4086
- let variant33;
4087
- switch (dataView(memory0).getUint8(ret + 0, true)) {
4088
- case 0: {
4089
- var len31 = dataView(memory0).getInt32(ret + 8, true);
4090
- var base31 = dataView(memory0).getInt32(ret + 4, true);
4091
- var result31 = [];
4092
- for (let i = 0; i < len31; i++) {
4093
- const base = base31 + i * 16;
4094
- var ptr29 = dataView(memory0).getInt32(base + 0, true);
4095
- var len29 = dataView(memory0).getInt32(base + 4, true);
4096
- var result29 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr29, len29));
4097
- var ptr30 = dataView(memory0).getInt32(base + 8, true);
4098
- var len30 = dataView(memory0).getInt32(base + 12, true);
4099
- var result30 = new Uint8Array(memory0.buffer.slice(ptr30, ptr30 + len30 * 1));
4100
- result31.push([result29, result30]);
4101
- }
4102
- variant33= {
4103
- tag: 'ok',
4104
- val: result31
4105
- };
4106
- break;
4107
- }
4108
- case 1: {
4109
- var ptr32 = dataView(memory0).getInt32(ret + 4, true);
4110
- var len32 = dataView(memory0).getInt32(ret + 8, true);
4111
- var result32 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr32, len32));
4112
- variant33= {
4113
- tag: 'err',
4114
- val: result32
4115
- };
4116
- break;
4117
- }
4118
- default: {
4119
- throw new TypeError('invalid variant discriminant for expected');
4120
- }
4121
- }
4122
- const retVal = variant33;
4123
- postReturn1(ret);
4124
- if (typeof retVal === 'object' && retVal.tag === 'err') {
4125
- throw new ComponentError(retVal.val);
4126
- }
4127
- return retVal.val;
4128
- }
4129
-
4130
- let _initialized = false;
4131
- export const $init = (() => {
4132
- let gen = (function* init () {
4133
- const module0 = fetchCompile(new URL('./js-component-bindgen-component.core.wasm', import.meta.url));
4134
- const module1 = fetchCompile(new URL('./js-component-bindgen-component.core2.wasm', import.meta.url));
4135
- const module2 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwADJiUHCAkCAgQEAgIKAgsBAQAAAAUDAwAAAAUMAAMDAAYGAA0BAQEBBAUBcAElJQe7ASYBMAAAATEAAQEyAAIBMwADATQABAE1AAUBNgAGATcABwE4AAgBOQAJAjEwAAoCMTEACwIxMgAMAjEzAA0CMTQADgIxNQAPAjE2ABACMTcAEQIxOAASAjE5ABMCMjAAFAIyMQAVAjIyABYCMjMAFwIyNAAYAjI1ABkCMjYAGgIyNwAbAjI4ABwCMjkAHQIzMAAeAjMxAB8CMzIAIAIzMwAhAjM0ACICMzUAIwIzNgAkCCRpbXBvcnRzAQAK+QMlGQAgACABIAIgAyAEIAUgBiAHIAhBABEHAAsRACAAIAEgAiADIARBAREIAAsRACAAIAEgAiADIARBAhEJAAsLACAAIAFBAxECAAsLACAAIAFBBBECAAsPACAAIAEgAiADQQURBAALDwAgACABIAIgA0EGEQQACwsAIAAgAUEHEQIACwsAIAAgAUEIEQIACwkAIABBCREKAAsLACAAIAFBChECAAsNACAAIAEgAkELEQsACwkAIABBDBEBAAsJACAAQQ0RAQALCwAgACABQQ4RAAALCwAgACABQQ8RAAALCwAgACABQRARAAALEQAgACABIAIgAyAEQRERBQALDQAgACABIAJBEhEDAAsNACAAIAEgAkETEQMACwsAIAAgAUEUEQAACwsAIAAgAUEVEQAACwsAIAAgAUEWEQAACxEAIAAgASACIAMgBEEXEQUACxUAIAAgASACIAMgBCAFIAZBGBEMAAsLACAAIAFBGREAAAsNACAAIAEgAkEaEQMACw0AIAAgASACQRsRAwALCwAgACABQRwRAAALDwAgACABIAIgA0EdEQYACw8AIAAgASACIANBHhEGAAsLACAAIAFBHxEAAAsLACAAIAFBIBENAAsJACAAQSERAQALCQAgAEEiEQEACwkAIABBIxEBAAsJACAAQSQRAQALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yMjUuMA');
4136
- const module3 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwAC5AEmAAEwAAcAATEACAABMgAJAAEzAAIAATQAAgABNQAEAAE2AAQAATcAAgABOAACAAE5AAoAAjEwAAIAAjExAAsAAjEyAAEAAjEzAAEAAjE0AAAAAjE1AAAAAjE2AAAAAjE3AAUAAjE4AAMAAjE5AAMAAjIwAAAAAjIxAAAAAjIyAAAAAjIzAAUAAjI0AAwAAjI1AAAAAjI2AAMAAjI3AAMAAjI4AAAAAjI5AAYAAjMwAAYAAjMxAAAAAjMyAA0AAjMzAAEAAjM0AAEAAjM1AAEAAjM2AAEACCRpbXBvcnRzAXABJSUJKwEAQQALJQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQALwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAcwLjIyNS4w');
4137
- ({ exports: exports0 } = yield instantiateCore(yield module2));
4138
- ({ exports: exports1 } = yield instantiateCore(yield module0, {
4139
- wasi_snapshot_preview1: {
4140
- environ_get: exports0['7'],
4141
- environ_sizes_get: exports0['8'],
4142
- fd_close: exports0['9'],
4143
- fd_filestat_get: exports0['4'],
4144
- fd_prestat_dir_name: exports0['11'],
4145
- fd_prestat_get: exports0['10'],
4146
- fd_read: exports0['5'],
4147
- fd_readdir: exports0['1'],
4148
- fd_write: exports0['6'],
4149
- path_filestat_get: exports0['2'],
4150
- path_open: exports0['0'],
4151
- proc_exit: exports0['12'],
4152
- random_get: exports0['3'],
4153
- },
4154
- }));
4155
- ({ exports: exports2 } = yield instantiateCore(yield module1, {
4156
- __main_module__: {
4157
- cabi_realloc: exports1.cabi_realloc,
4158
- },
4159
- env: {
4160
- memory: exports1.memory,
4161
- },
4162
- 'wasi:cli/environment@0.2.3': {
4163
- 'get-environment': exports0['13'],
4164
- },
4165
- 'wasi:cli/exit@0.2.3': {
4166
- exit: trampoline10,
4167
- },
4168
- 'wasi:cli/stderr@0.2.3': {
4169
- 'get-stderr': trampoline5,
4170
- },
4171
- 'wasi:cli/stdin@0.2.3': {
4172
- 'get-stdin': trampoline8,
4173
- },
4174
- 'wasi:cli/stdout@0.2.3': {
4175
- 'get-stdout': trampoline9,
4176
- },
4177
- 'wasi:cli/terminal-input@0.2.3': {
4178
- '[resource-drop]terminal-input': trampoline6,
4179
- },
4180
- 'wasi:cli/terminal-output@0.2.3': {
4181
- '[resource-drop]terminal-output': trampoline7,
4182
- },
4183
- 'wasi:cli/terminal-stderr@0.2.3': {
4184
- 'get-terminal-stderr': exports0['36'],
4185
- },
4186
- 'wasi:cli/terminal-stdin@0.2.3': {
4187
- 'get-terminal-stdin': exports0['34'],
4188
- },
4189
- 'wasi:cli/terminal-stdout@0.2.3': {
4190
- 'get-terminal-stdout': exports0['35'],
4191
- },
4192
- 'wasi:filesystem/preopens@0.2.3': {
4193
- 'get-directories': exports0['33'],
4194
- },
4195
- 'wasi:filesystem/types@0.2.3': {
4196
- '[method]descriptor.append-via-stream': exports0['20'],
4197
- '[method]descriptor.get-type': exports0['14'],
4198
- '[method]descriptor.metadata-hash': exports0['15'],
4199
- '[method]descriptor.metadata-hash-at': exports0['17'],
4200
- '[method]descriptor.open-at': exports0['24'],
4201
- '[method]descriptor.read-directory': exports0['21'],
4202
- '[method]descriptor.read-via-stream': exports0['18'],
4203
- '[method]descriptor.stat': exports0['22'],
4204
- '[method]descriptor.stat-at': exports0['23'],
4205
- '[method]descriptor.write-via-stream': exports0['19'],
4206
- '[method]directory-entry-stream.read-directory-entry': exports0['25'],
4207
- '[resource-drop]descriptor': trampoline4,
4208
- '[resource-drop]directory-entry-stream': trampoline0,
4209
- 'filesystem-error-code': exports0['16'],
4210
- },
4211
- 'wasi:io/error@0.2.3': {
4212
- '[resource-drop]error': trampoline2,
4213
- },
4214
- 'wasi:io/streams@0.2.3': {
4215
- '[method]input-stream.blocking-read': exports0['27'],
4216
- '[method]input-stream.read': exports0['26'],
4217
- '[method]output-stream.blocking-flush': exports0['31'],
4218
- '[method]output-stream.blocking-write-and-flush': exports0['30'],
4219
- '[method]output-stream.check-write': exports0['28'],
4220
- '[method]output-stream.write': exports0['29'],
4221
- '[resource-drop]input-stream': trampoline3,
4222
- '[resource-drop]output-stream': trampoline1,
4223
- },
4224
- 'wasi:random/random@0.2.3': {
4225
- 'get-random-bytes': exports0['32'],
4226
- },
4227
- }));
4228
- memory0 = exports1.memory;
4229
- realloc0 = exports2.cabi_import_realloc;
4230
- ({ exports: exports3 } = yield instantiateCore(yield module3, {
4231
- '': {
4232
- $imports: exports0.$imports,
4233
- '0': exports2.path_open,
4234
- '1': exports2.fd_readdir,
4235
- '10': exports2.fd_prestat_get,
4236
- '11': exports2.fd_prestat_dir_name,
4237
- '12': exports2.proc_exit,
4238
- '13': trampoline11,
4239
- '14': trampoline12,
4240
- '15': trampoline13,
4241
- '16': trampoline14,
4242
- '17': trampoline15,
4243
- '18': trampoline16,
4244
- '19': trampoline17,
4245
- '2': exports2.path_filestat_get,
4246
- '20': trampoline18,
4247
- '21': trampoline19,
4248
- '22': trampoline20,
4249
- '23': trampoline21,
4250
- '24': trampoline22,
4251
- '25': trampoline23,
4252
- '26': trampoline24,
4253
- '27': trampoline25,
4254
- '28': trampoline26,
4255
- '29': trampoline27,
4256
- '3': exports2.random_get,
4257
- '30': trampoline28,
4258
- '31': trampoline29,
4259
- '32': trampoline30,
4260
- '33': trampoline31,
4261
- '34': trampoline32,
4262
- '35': trampoline33,
4263
- '36': trampoline34,
4264
- '4': exports2.fd_filestat_get,
4265
- '5': exports2.fd_read,
4266
- '6': exports2.fd_write,
4267
- '7': exports2.environ_get,
4268
- '8': exports2.environ_sizes_get,
4269
- '9': exports2.fd_close,
4270
- },
4271
- }));
4272
- realloc1 = exports1.cabi_realloc;
4273
- postReturn0 = exports1.cabi_post_generate;
4274
- postReturn1 = exports1['cabi_post_generate-types'];
4275
- _initialized = true;
4276
- exports1Generate = exports1.generate;
4277
- exports1GenerateTypes = exports1['generate-types'];
4278
- })();
4279
- let promise, resolve, reject;
4280
- function runNext (value) {
4281
- try {
4282
- let done;
4283
- do {
4284
- ({ value, done } = gen.next(value));
4285
- } while (!(value instanceof Promise) && !done);
4286
- if (done) {
4287
- if (resolve) resolve(value);
4288
- else return value;
4289
- }
4290
- if (!promise) promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
4291
- value.then(runNext, reject);
4292
- }
4293
- catch (e) {
4294
- if (reject) reject(e);
4295
- else throw e;
4296
- }
4297
- }
4298
- const maybeSyncReturn = runNext(null);
4299
- return promise || maybeSyncReturn;
4300
- })();
4301
-
4302
- export { generate, generateTypes, }