@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
package/obj/wasm-tools.js DELETED
@@ -1,4369 +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 toolsParse;
3587
-
3588
- function parse(arg0) {
3589
- if (!_initialized) throwUninitialized();
3590
- var ptr0 = utf8Encode(arg0, realloc1, memory0);
3591
- var len0 = utf8EncodedLen;
3592
- const ret = toolsParse(ptr0, len0);
3593
- let variant3;
3594
- switch (dataView(memory0).getUint8(ret + 0, true)) {
3595
- case 0: {
3596
- var ptr1 = dataView(memory0).getInt32(ret + 4, true);
3597
- var len1 = dataView(memory0).getInt32(ret + 8, true);
3598
- var result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
3599
- variant3= {
3600
- tag: 'ok',
3601
- val: result1
3602
- };
3603
- break;
3604
- }
3605
- case 1: {
3606
- var ptr2 = dataView(memory0).getInt32(ret + 4, true);
3607
- var len2 = dataView(memory0).getInt32(ret + 8, true);
3608
- var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
3609
- variant3= {
3610
- tag: 'err',
3611
- val: result2
3612
- };
3613
- break;
3614
- }
3615
- default: {
3616
- throw new TypeError('invalid variant discriminant for expected');
3617
- }
3618
- }
3619
- const retVal = variant3;
3620
- postReturn0(ret);
3621
- if (typeof retVal === 'object' && retVal.tag === 'err') {
3622
- throw new ComponentError(retVal.val);
3623
- }
3624
- return retVal.val;
3625
- }
3626
- let toolsPrint;
3627
-
3628
- function print(arg0) {
3629
- if (!_initialized) throwUninitialized();
3630
- var val0 = arg0;
3631
- var len0 = val0.byteLength;
3632
- var ptr0 = realloc1(0, 0, 1, len0 * 1);
3633
- var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
3634
- (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
3635
- const ret = toolsPrint(ptr0, len0);
3636
- let variant3;
3637
- switch (dataView(memory0).getUint8(ret + 0, true)) {
3638
- case 0: {
3639
- var ptr1 = dataView(memory0).getInt32(ret + 4, true);
3640
- var len1 = dataView(memory0).getInt32(ret + 8, true);
3641
- var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
3642
- variant3= {
3643
- tag: 'ok',
3644
- val: result1
3645
- };
3646
- break;
3647
- }
3648
- case 1: {
3649
- var ptr2 = dataView(memory0).getInt32(ret + 4, true);
3650
- var len2 = dataView(memory0).getInt32(ret + 8, true);
3651
- var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
3652
- variant3= {
3653
- tag: 'err',
3654
- val: result2
3655
- };
3656
- break;
3657
- }
3658
- default: {
3659
- throw new TypeError('invalid variant discriminant for expected');
3660
- }
3661
- }
3662
- const retVal = variant3;
3663
- postReturn0(ret);
3664
- if (typeof retVal === 'object' && retVal.tag === 'err') {
3665
- throw new ComponentError(retVal.val);
3666
- }
3667
- return retVal.val;
3668
- }
3669
- let toolsComponentNew;
3670
-
3671
- function componentNew(arg0, arg1) {
3672
- if (!_initialized) throwUninitialized();
3673
- var val0 = arg0;
3674
- var len0 = val0.byteLength;
3675
- var ptr0 = realloc1(0, 0, 1, len0 * 1);
3676
- var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
3677
- (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
3678
- var variant5 = arg1;
3679
- let variant5_0;
3680
- let variant5_1;
3681
- let variant5_2;
3682
- if (variant5 === null || variant5=== undefined) {
3683
- variant5_0 = 0;
3684
- variant5_1 = 0;
3685
- variant5_2 = 0;
3686
- } else {
3687
- const e = variant5;
3688
- var vec4 = e;
3689
- var len4 = vec4.length;
3690
- var result4 = realloc1(0, 0, 4, len4 * 16);
3691
- for (let i = 0; i < vec4.length; i++) {
3692
- const e = vec4[i];
3693
- const base = result4 + i * 16;var [tuple1_0, tuple1_1] = e;
3694
- var ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
3695
- var len2 = utf8EncodedLen;
3696
- dataView(memory0).setInt32(base + 4, len2, true);
3697
- dataView(memory0).setInt32(base + 0, ptr2, true);
3698
- var val3 = tuple1_1;
3699
- var len3 = val3.byteLength;
3700
- var ptr3 = realloc1(0, 0, 1, len3 * 1);
3701
- var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
3702
- (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
3703
- dataView(memory0).setInt32(base + 12, len3, true);
3704
- dataView(memory0).setInt32(base + 8, ptr3, true);
3705
- }
3706
- variant5_0 = 1;
3707
- variant5_1 = result4;
3708
- variant5_2 = len4;
3709
- }
3710
- const ret = toolsComponentNew(ptr0, len0, variant5_0, variant5_1, variant5_2);
3711
- let variant8;
3712
- switch (dataView(memory0).getUint8(ret + 0, true)) {
3713
- case 0: {
3714
- var ptr6 = dataView(memory0).getInt32(ret + 4, true);
3715
- var len6 = dataView(memory0).getInt32(ret + 8, true);
3716
- var result6 = new Uint8Array(memory0.buffer.slice(ptr6, ptr6 + len6 * 1));
3717
- variant8= {
3718
- tag: 'ok',
3719
- val: result6
3720
- };
3721
- break;
3722
- }
3723
- case 1: {
3724
- var ptr7 = dataView(memory0).getInt32(ret + 4, true);
3725
- var len7 = dataView(memory0).getInt32(ret + 8, true);
3726
- var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
3727
- variant8= {
3728
- tag: 'err',
3729
- val: result7
3730
- };
3731
- break;
3732
- }
3733
- default: {
3734
- throw new TypeError('invalid variant discriminant for expected');
3735
- }
3736
- }
3737
- const retVal = variant8;
3738
- postReturn0(ret);
3739
- if (typeof retVal === 'object' && retVal.tag === 'err') {
3740
- throw new ComponentError(retVal.val);
3741
- }
3742
- return retVal.val;
3743
- }
3744
- let toolsComponentWit;
3745
-
3746
- function componentWit(arg0) {
3747
- if (!_initialized) throwUninitialized();
3748
- var val0 = arg0;
3749
- var len0 = val0.byteLength;
3750
- var ptr0 = realloc1(0, 0, 1, len0 * 1);
3751
- var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
3752
- (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
3753
- const ret = toolsComponentWit(ptr0, len0);
3754
- let variant3;
3755
- switch (dataView(memory0).getUint8(ret + 0, true)) {
3756
- case 0: {
3757
- var ptr1 = dataView(memory0).getInt32(ret + 4, true);
3758
- var len1 = dataView(memory0).getInt32(ret + 8, true);
3759
- var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
3760
- variant3= {
3761
- tag: 'ok',
3762
- val: result1
3763
- };
3764
- break;
3765
- }
3766
- case 1: {
3767
- var ptr2 = dataView(memory0).getInt32(ret + 4, true);
3768
- var len2 = dataView(memory0).getInt32(ret + 8, true);
3769
- var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
3770
- variant3= {
3771
- tag: 'err',
3772
- val: result2
3773
- };
3774
- break;
3775
- }
3776
- default: {
3777
- throw new TypeError('invalid variant discriminant for expected');
3778
- }
3779
- }
3780
- const retVal = variant3;
3781
- postReturn0(ret);
3782
- if (typeof retVal === 'object' && retVal.tag === 'err') {
3783
- throw new ComponentError(retVal.val);
3784
- }
3785
- return retVal.val;
3786
- }
3787
- let toolsComponentEmbed;
3788
-
3789
- function componentEmbed(arg0) {
3790
- if (!_initialized) throwUninitialized();
3791
- var ptr0 = realloc1(0, 0, 4, 80);
3792
- var {binary: v1_0, witSource: v1_1, witPath: v1_2, stringEncoding: v1_3, dummy: v1_4, world: v1_5, metadata: v1_6, features: v1_7 } = arg0;
3793
- var variant3 = v1_0;
3794
- if (variant3 === null || variant3=== undefined) {
3795
- dataView(memory0).setInt8(ptr0 + 0, 0, true);
3796
- } else {
3797
- const e = variant3;
3798
- dataView(memory0).setInt8(ptr0 + 0, 1, true);
3799
- var val2 = e;
3800
- var len2 = val2.byteLength;
3801
- var ptr2 = realloc1(0, 0, 1, len2 * 1);
3802
- var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
3803
- (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
3804
- dataView(memory0).setInt32(ptr0 + 8, len2, true);
3805
- dataView(memory0).setInt32(ptr0 + 4, ptr2, true);
3806
- }
3807
- var variant5 = v1_1;
3808
- if (variant5 === null || variant5=== undefined) {
3809
- dataView(memory0).setInt8(ptr0 + 12, 0, true);
3810
- } else {
3811
- const e = variant5;
3812
- dataView(memory0).setInt8(ptr0 + 12, 1, true);
3813
- var ptr4 = utf8Encode(e, realloc1, memory0);
3814
- var len4 = utf8EncodedLen;
3815
- dataView(memory0).setInt32(ptr0 + 20, len4, true);
3816
- dataView(memory0).setInt32(ptr0 + 16, ptr4, true);
3817
- }
3818
- var variant7 = v1_2;
3819
- if (variant7 === null || variant7=== undefined) {
3820
- dataView(memory0).setInt8(ptr0 + 24, 0, true);
3821
- } else {
3822
- const e = variant7;
3823
- dataView(memory0).setInt8(ptr0 + 24, 1, true);
3824
- var ptr6 = utf8Encode(e, realloc1, memory0);
3825
- var len6 = utf8EncodedLen;
3826
- dataView(memory0).setInt32(ptr0 + 32, len6, true);
3827
- dataView(memory0).setInt32(ptr0 + 28, ptr6, true);
3828
- }
3829
- var variant9 = v1_3;
3830
- if (variant9 === null || variant9=== undefined) {
3831
- dataView(memory0).setInt8(ptr0 + 36, 0, true);
3832
- } else {
3833
- const e = variant9;
3834
- dataView(memory0).setInt8(ptr0 + 36, 1, true);
3835
- var val8 = e;
3836
- let enum8;
3837
- switch (val8) {
3838
- case 'utf8': {
3839
- enum8 = 0;
3840
- break;
3841
- }
3842
- case 'utf16': {
3843
- enum8 = 1;
3844
- break;
3845
- }
3846
- case 'compact-utf16': {
3847
- enum8 = 2;
3848
- break;
3849
- }
3850
- default: {
3851
- if ((e) instanceof Error) {
3852
- console.error(e);
3853
- }
3854
-
3855
- throw new TypeError(`"${val8}" is not one of the cases of string-encoding`);
3856
- }
3857
- }
3858
- dataView(memory0).setInt8(ptr0 + 37, enum8, true);
3859
- }
3860
- var variant10 = v1_4;
3861
- if (variant10 === null || variant10=== undefined) {
3862
- dataView(memory0).setInt8(ptr0 + 38, 0, true);
3863
- } else {
3864
- const e = variant10;
3865
- dataView(memory0).setInt8(ptr0 + 38, 1, true);
3866
- dataView(memory0).setInt8(ptr0 + 39, e ? 1 : 0, true);
3867
- }
3868
- var variant12 = v1_5;
3869
- if (variant12 === null || variant12=== undefined) {
3870
- dataView(memory0).setInt8(ptr0 + 40, 0, true);
3871
- } else {
3872
- const e = variant12;
3873
- dataView(memory0).setInt8(ptr0 + 40, 1, true);
3874
- var ptr11 = utf8Encode(e, realloc1, memory0);
3875
- var len11 = utf8EncodedLen;
3876
- dataView(memory0).setInt32(ptr0 + 48, len11, true);
3877
- dataView(memory0).setInt32(ptr0 + 44, ptr11, true);
3878
- }
3879
- var variant20 = v1_6;
3880
- if (variant20 === null || variant20=== undefined) {
3881
- dataView(memory0).setInt8(ptr0 + 52, 0, true);
3882
- } else {
3883
- const e = variant20;
3884
- dataView(memory0).setInt8(ptr0 + 52, 1, true);
3885
- var vec19 = e;
3886
- var len19 = vec19.length;
3887
- var result19 = realloc1(0, 0, 4, len19 * 16);
3888
- for (let i = 0; i < vec19.length; i++) {
3889
- const e = vec19[i];
3890
- const base = result19 + i * 16;var [tuple13_0, tuple13_1] = e;
3891
- var ptr14 = utf8Encode(tuple13_0, realloc1, memory0);
3892
- var len14 = utf8EncodedLen;
3893
- dataView(memory0).setInt32(base + 4, len14, true);
3894
- dataView(memory0).setInt32(base + 0, ptr14, true);
3895
- var vec18 = tuple13_1;
3896
- var len18 = vec18.length;
3897
- var result18 = realloc1(0, 0, 4, len18 * 16);
3898
- for (let i = 0; i < vec18.length; i++) {
3899
- const e = vec18[i];
3900
- const base = result18 + i * 16;var [tuple15_0, tuple15_1] = e;
3901
- var ptr16 = utf8Encode(tuple15_0, realloc1, memory0);
3902
- var len16 = utf8EncodedLen;
3903
- dataView(memory0).setInt32(base + 4, len16, true);
3904
- dataView(memory0).setInt32(base + 0, ptr16, true);
3905
- var ptr17 = utf8Encode(tuple15_1, realloc1, memory0);
3906
- var len17 = utf8EncodedLen;
3907
- dataView(memory0).setInt32(base + 12, len17, true);
3908
- dataView(memory0).setInt32(base + 8, ptr17, true);
3909
- }
3910
- dataView(memory0).setInt32(base + 12, len18, true);
3911
- dataView(memory0).setInt32(base + 8, result18, true);
3912
- }
3913
- dataView(memory0).setInt32(ptr0 + 60, len19, true);
3914
- dataView(memory0).setInt32(ptr0 + 56, result19, true);
3915
- }
3916
- var variant24 = v1_7;
3917
- if (variant24 === null || variant24=== undefined) {
3918
- dataView(memory0).setInt8(ptr0 + 64, 0, true);
3919
- } else {
3920
- const e = variant24;
3921
- dataView(memory0).setInt8(ptr0 + 64, 1, true);
3922
- var variant23 = e;
3923
- switch (variant23.tag) {
3924
- case 'list': {
3925
- const e = variant23.val;
3926
- dataView(memory0).setInt8(ptr0 + 68, 0, true);
3927
- var vec22 = e;
3928
- var len22 = vec22.length;
3929
- var result22 = realloc1(0, 0, 4, len22 * 8);
3930
- for (let i = 0; i < vec22.length; i++) {
3931
- const e = vec22[i];
3932
- const base = result22 + i * 8;var ptr21 = utf8Encode(e, realloc1, memory0);
3933
- var len21 = utf8EncodedLen;
3934
- dataView(memory0).setInt32(base + 4, len21, true);
3935
- dataView(memory0).setInt32(base + 0, ptr21, true);
3936
- }
3937
- dataView(memory0).setInt32(ptr0 + 76, len22, true);
3938
- dataView(memory0).setInt32(ptr0 + 72, result22, true);
3939
- break;
3940
- }
3941
- case 'all': {
3942
- dataView(memory0).setInt8(ptr0 + 68, 1, true);
3943
- break;
3944
- }
3945
- default: {
3946
- throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant23.tag)}\` (received \`${variant23}\`) specified for \`EnabledFeatureSet\``);
3947
- }
3948
- }
3949
- }
3950
- const ret = toolsComponentEmbed(ptr0);
3951
- let variant27;
3952
- switch (dataView(memory0).getUint8(ret + 0, true)) {
3953
- case 0: {
3954
- var ptr25 = dataView(memory0).getInt32(ret + 4, true);
3955
- var len25 = dataView(memory0).getInt32(ret + 8, true);
3956
- var result25 = new Uint8Array(memory0.buffer.slice(ptr25, ptr25 + len25 * 1));
3957
- variant27= {
3958
- tag: 'ok',
3959
- val: result25
3960
- };
3961
- break;
3962
- }
3963
- case 1: {
3964
- var ptr26 = dataView(memory0).getInt32(ret + 4, true);
3965
- var len26 = dataView(memory0).getInt32(ret + 8, true);
3966
- var result26 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr26, len26));
3967
- variant27= {
3968
- tag: 'err',
3969
- val: result26
3970
- };
3971
- break;
3972
- }
3973
- default: {
3974
- throw new TypeError('invalid variant discriminant for expected');
3975
- }
3976
- }
3977
- const retVal = variant27;
3978
- postReturn0(ret);
3979
- if (typeof retVal === 'object' && retVal.tag === 'err') {
3980
- throw new ComponentError(retVal.val);
3981
- }
3982
- return retVal.val;
3983
- }
3984
- let toolsMetadataShow;
3985
-
3986
- function metadataShow(arg0) {
3987
- if (!_initialized) throwUninitialized();
3988
- var val0 = arg0;
3989
- var len0 = val0.byteLength;
3990
- var ptr0 = realloc1(0, 0, 1, len0 * 1);
3991
- var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
3992
- (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
3993
- const ret = toolsMetadataShow(ptr0, len0);
3994
- let variant12;
3995
- switch (dataView(memory0).getUint8(ret + 0, true)) {
3996
- case 0: {
3997
- var len10 = dataView(memory0).getInt32(ret + 8, true);
3998
- var base10 = dataView(memory0).getInt32(ret + 4, true);
3999
- var result10 = [];
4000
- for (let i = 0; i < len10; i++) {
4001
- const base = base10 + i * 44;
4002
- let variant1;
4003
- switch (dataView(memory0).getUint8(base + 0, true)) {
4004
- case 0: {
4005
- variant1 = undefined;
4006
- break;
4007
- }
4008
- case 1: {
4009
- variant1 = dataView(memory0).getInt32(base + 4, true) >>> 0;
4010
- break;
4011
- }
4012
- default: {
4013
- throw new TypeError('invalid variant discriminant for option');
4014
- }
4015
- }
4016
- let variant3;
4017
- switch (dataView(memory0).getUint8(base + 8, true)) {
4018
- case 0: {
4019
- variant3 = undefined;
4020
- break;
4021
- }
4022
- case 1: {
4023
- var ptr2 = dataView(memory0).getInt32(base + 12, true);
4024
- var len2 = dataView(memory0).getInt32(base + 16, true);
4025
- var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
4026
- variant3 = result2;
4027
- break;
4028
- }
4029
- default: {
4030
- throw new TypeError('invalid variant discriminant for option');
4031
- }
4032
- }
4033
- let variant4;
4034
- switch (dataView(memory0).getUint8(base + 20, true)) {
4035
- case 0: {
4036
- variant4= {
4037
- tag: 'module',
4038
- };
4039
- break;
4040
- }
4041
- case 1: {
4042
- variant4= {
4043
- tag: 'component',
4044
- val: dataView(memory0).getInt32(base + 24, true) >>> 0
4045
- };
4046
- break;
4047
- }
4048
- default: {
4049
- throw new TypeError('invalid variant discriminant for ModuleMetaType');
4050
- }
4051
- }
4052
- var len9 = dataView(memory0).getInt32(base + 40, true);
4053
- var base9 = dataView(memory0).getInt32(base + 36, true);
4054
- var result9 = [];
4055
- for (let i = 0; i < len9; i++) {
4056
- const base = base9 + i * 16;
4057
- var ptr5 = dataView(memory0).getInt32(base + 0, true);
4058
- var len5 = dataView(memory0).getInt32(base + 4, true);
4059
- var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
4060
- var len8 = dataView(memory0).getInt32(base + 12, true);
4061
- var base8 = dataView(memory0).getInt32(base + 8, true);
4062
- var result8 = [];
4063
- for (let i = 0; i < len8; i++) {
4064
- const base = base8 + i * 16;
4065
- var ptr6 = dataView(memory0).getInt32(base + 0, true);
4066
- var len6 = dataView(memory0).getInt32(base + 4, true);
4067
- var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
4068
- var ptr7 = dataView(memory0).getInt32(base + 8, true);
4069
- var len7 = dataView(memory0).getInt32(base + 12, true);
4070
- var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
4071
- result8.push([result6, result7]);
4072
- }
4073
- result9.push([result5, result8]);
4074
- }
4075
- result10.push({
4076
- parentIndex: variant1,
4077
- name: variant3,
4078
- metaType: variant4,
4079
- range: [dataView(memory0).getInt32(base + 28, true) >>> 0, dataView(memory0).getInt32(base + 32, true) >>> 0],
4080
- producers: result9,
4081
- });
4082
- }
4083
- variant12= {
4084
- tag: 'ok',
4085
- val: result10
4086
- };
4087
- break;
4088
- }
4089
- case 1: {
4090
- var ptr11 = dataView(memory0).getInt32(ret + 4, true);
4091
- var len11 = dataView(memory0).getInt32(ret + 8, true);
4092
- var result11 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr11, len11));
4093
- variant12= {
4094
- tag: 'err',
4095
- val: result11
4096
- };
4097
- break;
4098
- }
4099
- default: {
4100
- throw new TypeError('invalid variant discriminant for expected');
4101
- }
4102
- }
4103
- const retVal = variant12;
4104
- postReturn1(ret);
4105
- if (typeof retVal === 'object' && retVal.tag === 'err') {
4106
- throw new ComponentError(retVal.val);
4107
- }
4108
- return retVal.val;
4109
- }
4110
- let toolsMetadataAdd;
4111
-
4112
- function metadataAdd(arg0, arg1) {
4113
- if (!_initialized) throwUninitialized();
4114
- var val0 = arg0;
4115
- var len0 = val0.byteLength;
4116
- var ptr0 = realloc1(0, 0, 1, len0 * 1);
4117
- var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
4118
- (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
4119
- var vec7 = arg1;
4120
- var len7 = vec7.length;
4121
- var result7 = realloc1(0, 0, 4, len7 * 16);
4122
- for (let i = 0; i < vec7.length; i++) {
4123
- const e = vec7[i];
4124
- const base = result7 + i * 16;var [tuple1_0, tuple1_1] = e;
4125
- var ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
4126
- var len2 = utf8EncodedLen;
4127
- dataView(memory0).setInt32(base + 4, len2, true);
4128
- dataView(memory0).setInt32(base + 0, ptr2, true);
4129
- var vec6 = tuple1_1;
4130
- var len6 = vec6.length;
4131
- var result6 = realloc1(0, 0, 4, len6 * 16);
4132
- for (let i = 0; i < vec6.length; i++) {
4133
- const e = vec6[i];
4134
- const base = result6 + i * 16;var [tuple3_0, tuple3_1] = e;
4135
- var ptr4 = utf8Encode(tuple3_0, realloc1, memory0);
4136
- var len4 = utf8EncodedLen;
4137
- dataView(memory0).setInt32(base + 4, len4, true);
4138
- dataView(memory0).setInt32(base + 0, ptr4, true);
4139
- var ptr5 = utf8Encode(tuple3_1, realloc1, memory0);
4140
- var len5 = utf8EncodedLen;
4141
- dataView(memory0).setInt32(base + 12, len5, true);
4142
- dataView(memory0).setInt32(base + 8, ptr5, true);
4143
- }
4144
- dataView(memory0).setInt32(base + 12, len6, true);
4145
- dataView(memory0).setInt32(base + 8, result6, true);
4146
- }
4147
- const ret = toolsMetadataAdd(ptr0, len0, result7, len7);
4148
- let variant10;
4149
- switch (dataView(memory0).getUint8(ret + 0, true)) {
4150
- case 0: {
4151
- var ptr8 = dataView(memory0).getInt32(ret + 4, true);
4152
- var len8 = dataView(memory0).getInt32(ret + 8, true);
4153
- var result8 = new Uint8Array(memory0.buffer.slice(ptr8, ptr8 + len8 * 1));
4154
- variant10= {
4155
- tag: 'ok',
4156
- val: result8
4157
- };
4158
- break;
4159
- }
4160
- case 1: {
4161
- var ptr9 = dataView(memory0).getInt32(ret + 4, true);
4162
- var len9 = dataView(memory0).getInt32(ret + 8, true);
4163
- var result9 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9));
4164
- variant10= {
4165
- tag: 'err',
4166
- val: result9
4167
- };
4168
- break;
4169
- }
4170
- default: {
4171
- throw new TypeError('invalid variant discriminant for expected');
4172
- }
4173
- }
4174
- const retVal = variant10;
4175
- postReturn0(ret);
4176
- if (typeof retVal === 'object' && retVal.tag === 'err') {
4177
- throw new ComponentError(retVal.val);
4178
- }
4179
- return retVal.val;
4180
- }
4181
-
4182
- let _initialized = false;
4183
- export const $init = (() => {
4184
- let gen = (function* init () {
4185
- const module0 = fetchCompile(new URL('./wasm-tools.core.wasm', import.meta.url));
4186
- const module1 = fetchCompile(new URL('./wasm-tools.core2.wasm', import.meta.url));
4187
- const module2 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwADJiUHCAkCAgQEAgIKAgsBAQAAAAUDAwAAAAUMAAMDAAYGAA0BAQEBBAUBcAElJQe7ASYBMAAAATEAAQEyAAIBMwADATQABAE1AAUBNgAGATcABwE4AAgBOQAJAjEwAAoCMTEACwIxMgAMAjEzAA0CMTQADgIxNQAPAjE2ABACMTcAEQIxOAASAjE5ABMCMjAAFAIyMQAVAjIyABYCMjMAFwIyNAAYAjI1ABkCMjYAGgIyNwAbAjI4ABwCMjkAHQIzMAAeAjMxAB8CMzIAIAIzMwAhAjM0ACICMzUAIwIzNgAkCCRpbXBvcnRzAQAK+QMlGQAgACABIAIgAyAEIAUgBiAHIAhBABEHAAsRACAAIAEgAiADIARBAREIAAsRACAAIAEgAiADIARBAhEJAAsLACAAIAFBAxECAAsLACAAIAFBBBECAAsPACAAIAEgAiADQQURBAALDwAgACABIAIgA0EGEQQACwsAIAAgAUEHEQIACwsAIAAgAUEIEQIACwkAIABBCREKAAsLACAAIAFBChECAAsNACAAIAEgAkELEQsACwkAIABBDBEBAAsJACAAQQ0RAQALCwAgACABQQ4RAAALCwAgACABQQ8RAAALCwAgACABQRARAAALEQAgACABIAIgAyAEQRERBQALDQAgACABIAJBEhEDAAsNACAAIAEgAkETEQMACwsAIAAgAUEUEQAACwsAIAAgAUEVEQAACwsAIAAgAUEWEQAACxEAIAAgASACIAMgBEEXEQUACxUAIAAgASACIAMgBCAFIAZBGBEMAAsLACAAIAFBGREAAAsNACAAIAEgAkEaEQMACw0AIAAgASACQRsRAwALCwAgACABQRwRAAALDwAgACABIAIgA0EdEQYACw8AIAAgASACIANBHhEGAAsLACAAIAFBHxEAAAsLACAAIAFBIBENAAsJACAAQSERAQALCQAgAEEiEQEACwkAIABBIxEBAAsJACAAQSQRAQALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yMjUuMA');
4188
- const module3 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwAC5AEmAAEwAAcAATEACAABMgAJAAEzAAIAATQAAgABNQAEAAE2AAQAATcAAgABOAACAAE5AAoAAjEwAAIAAjExAAsAAjEyAAEAAjEzAAEAAjE0AAAAAjE1AAAAAjE2AAAAAjE3AAUAAjE4AAMAAjE5AAMAAjIwAAAAAjIxAAAAAjIyAAAAAjIzAAUAAjI0AAwAAjI1AAAAAjI2AAMAAjI3AAMAAjI4AAAAAjI5AAYAAjMwAAYAAjMxAAAAAjMyAA0AAjMzAAEAAjM0AAEAAjM1AAEAAjM2AAEACCRpbXBvcnRzAXABJSUJKwEAQQALJQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQALwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAcwLjIyNS4w');
4189
- ({ exports: exports0 } = yield instantiateCore(yield module2));
4190
- ({ exports: exports1 } = yield instantiateCore(yield module0, {
4191
- wasi_snapshot_preview1: {
4192
- environ_get: exports0['7'],
4193
- environ_sizes_get: exports0['8'],
4194
- fd_close: exports0['9'],
4195
- fd_filestat_get: exports0['4'],
4196
- fd_prestat_dir_name: exports0['11'],
4197
- fd_prestat_get: exports0['10'],
4198
- fd_read: exports0['5'],
4199
- fd_readdir: exports0['1'],
4200
- fd_write: exports0['6'],
4201
- path_filestat_get: exports0['2'],
4202
- path_open: exports0['0'],
4203
- proc_exit: exports0['12'],
4204
- random_get: exports0['3'],
4205
- },
4206
- }));
4207
- ({ exports: exports2 } = yield instantiateCore(yield module1, {
4208
- __main_module__: {
4209
- cabi_realloc: exports1.cabi_realloc,
4210
- },
4211
- env: {
4212
- memory: exports1.memory,
4213
- },
4214
- 'wasi:cli/environment@0.2.3': {
4215
- 'get-environment': exports0['13'],
4216
- },
4217
- 'wasi:cli/exit@0.2.3': {
4218
- exit: trampoline10,
4219
- },
4220
- 'wasi:cli/stderr@0.2.3': {
4221
- 'get-stderr': trampoline5,
4222
- },
4223
- 'wasi:cli/stdin@0.2.3': {
4224
- 'get-stdin': trampoline8,
4225
- },
4226
- 'wasi:cli/stdout@0.2.3': {
4227
- 'get-stdout': trampoline9,
4228
- },
4229
- 'wasi:cli/terminal-input@0.2.3': {
4230
- '[resource-drop]terminal-input': trampoline6,
4231
- },
4232
- 'wasi:cli/terminal-output@0.2.3': {
4233
- '[resource-drop]terminal-output': trampoline7,
4234
- },
4235
- 'wasi:cli/terminal-stderr@0.2.3': {
4236
- 'get-terminal-stderr': exports0['36'],
4237
- },
4238
- 'wasi:cli/terminal-stdin@0.2.3': {
4239
- 'get-terminal-stdin': exports0['34'],
4240
- },
4241
- 'wasi:cli/terminal-stdout@0.2.3': {
4242
- 'get-terminal-stdout': exports0['35'],
4243
- },
4244
- 'wasi:filesystem/preopens@0.2.3': {
4245
- 'get-directories': exports0['33'],
4246
- },
4247
- 'wasi:filesystem/types@0.2.3': {
4248
- '[method]descriptor.append-via-stream': exports0['20'],
4249
- '[method]descriptor.get-type': exports0['14'],
4250
- '[method]descriptor.metadata-hash': exports0['15'],
4251
- '[method]descriptor.metadata-hash-at': exports0['17'],
4252
- '[method]descriptor.open-at': exports0['24'],
4253
- '[method]descriptor.read-directory': exports0['21'],
4254
- '[method]descriptor.read-via-stream': exports0['18'],
4255
- '[method]descriptor.stat': exports0['22'],
4256
- '[method]descriptor.stat-at': exports0['23'],
4257
- '[method]descriptor.write-via-stream': exports0['19'],
4258
- '[method]directory-entry-stream.read-directory-entry': exports0['25'],
4259
- '[resource-drop]descriptor': trampoline4,
4260
- '[resource-drop]directory-entry-stream': trampoline0,
4261
- 'filesystem-error-code': exports0['16'],
4262
- },
4263
- 'wasi:io/error@0.2.3': {
4264
- '[resource-drop]error': trampoline2,
4265
- },
4266
- 'wasi:io/streams@0.2.3': {
4267
- '[method]input-stream.blocking-read': exports0['27'],
4268
- '[method]input-stream.read': exports0['26'],
4269
- '[method]output-stream.blocking-flush': exports0['31'],
4270
- '[method]output-stream.blocking-write-and-flush': exports0['30'],
4271
- '[method]output-stream.check-write': exports0['28'],
4272
- '[method]output-stream.write': exports0['29'],
4273
- '[resource-drop]input-stream': trampoline3,
4274
- '[resource-drop]output-stream': trampoline1,
4275
- },
4276
- 'wasi:random/random@0.2.3': {
4277
- 'get-random-bytes': exports0['32'],
4278
- },
4279
- }));
4280
- memory0 = exports1.memory;
4281
- realloc0 = exports2.cabi_import_realloc;
4282
- ({ exports: exports3 } = yield instantiateCore(yield module3, {
4283
- '': {
4284
- $imports: exports0.$imports,
4285
- '0': exports2.path_open,
4286
- '1': exports2.fd_readdir,
4287
- '10': exports2.fd_prestat_get,
4288
- '11': exports2.fd_prestat_dir_name,
4289
- '12': exports2.proc_exit,
4290
- '13': trampoline11,
4291
- '14': trampoline12,
4292
- '15': trampoline13,
4293
- '16': trampoline14,
4294
- '17': trampoline15,
4295
- '18': trampoline16,
4296
- '19': trampoline17,
4297
- '2': exports2.path_filestat_get,
4298
- '20': trampoline18,
4299
- '21': trampoline19,
4300
- '22': trampoline20,
4301
- '23': trampoline21,
4302
- '24': trampoline22,
4303
- '25': trampoline23,
4304
- '26': trampoline24,
4305
- '27': trampoline25,
4306
- '28': trampoline26,
4307
- '29': trampoline27,
4308
- '3': exports2.random_get,
4309
- '30': trampoline28,
4310
- '31': trampoline29,
4311
- '32': trampoline30,
4312
- '33': trampoline31,
4313
- '34': trampoline32,
4314
- '35': trampoline33,
4315
- '36': trampoline34,
4316
- '4': exports2.fd_filestat_get,
4317
- '5': exports2.fd_read,
4318
- '6': exports2.fd_write,
4319
- '7': exports2.environ_get,
4320
- '8': exports2.environ_sizes_get,
4321
- '9': exports2.fd_close,
4322
- },
4323
- }));
4324
- realloc1 = exports1.cabi_realloc;
4325
- postReturn0 = exports1['cabi_post_local:wasm-tools/tools#component-embed'];
4326
- postReturn1 = exports1['cabi_post_local:wasm-tools/tools#metadata-show'];
4327
- _initialized = true;
4328
- toolsParse = exports1['local:wasm-tools/tools#parse'];
4329
- toolsPrint = exports1['local:wasm-tools/tools#print'];
4330
- toolsComponentNew = exports1['local:wasm-tools/tools#component-new'];
4331
- toolsComponentWit = exports1['local:wasm-tools/tools#component-wit'];
4332
- toolsComponentEmbed = exports1['local:wasm-tools/tools#component-embed'];
4333
- toolsMetadataShow = exports1['local:wasm-tools/tools#metadata-show'];
4334
- toolsMetadataAdd = exports1['local:wasm-tools/tools#metadata-add'];
4335
- })();
4336
- let promise, resolve, reject;
4337
- function runNext (value) {
4338
- try {
4339
- let done;
4340
- do {
4341
- ({ value, done } = gen.next(value));
4342
- } while (!(value instanceof Promise) && !done);
4343
- if (done) {
4344
- if (resolve) resolve(value);
4345
- else return value;
4346
- }
4347
- if (!promise) promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
4348
- value.then(runNext, reject);
4349
- }
4350
- catch (e) {
4351
- if (reject) reject(e);
4352
- else throw e;
4353
- }
4354
- }
4355
- const maybeSyncReturn = runNext(null);
4356
- return promise || maybeSyncReturn;
4357
- })();
4358
- const tools = {
4359
- componentEmbed: componentEmbed,
4360
- componentNew: componentNew,
4361
- componentWit: componentWit,
4362
- metadataAdd: metadataAdd,
4363
- metadataShow: metadataShow,
4364
- parse: parse,
4365
- print: print,
4366
-
4367
- };
4368
-
4369
- export { tools, }