@bytecodealliance/jco 1.7.0 → 1.7.2

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 (10) hide show
  1. package/lib/wasi_snapshot_preview1.command.wasm +0 -0
  2. package/lib/wasi_snapshot_preview1.reactor.wasm +0 -0
  3. package/obj/js-component-bindgen-component.core.wasm +0 -0
  4. package/obj/js-component-bindgen-component.core2.wasm +0 -0
  5. package/obj/js-component-bindgen-component.js +1162 -1162
  6. package/obj/wasm-tools.core.wasm +0 -0
  7. package/obj/wasm-tools.core2.wasm +0 -0
  8. package/obj/wasm-tools.js +1162 -1162
  9. package/package.json +6 -6
  10. package/src/jco.js +1 -1
package/obj/wasm-tools.js CHANGED
@@ -40,7 +40,7 @@ const isNode = typeof process !== 'undefined' && process.versions && process.ver
40
40
  let _fs;
41
41
  async function fetchCompile (url) {
42
42
  if (isNode) {
43
- _fs = _fs || await import('fs/promises');
43
+ _fs = _fs || await import('node:fs/promises');
44
44
  return WebAssembly.compile(await _fs.readFile(url));
45
45
  }
46
46
  return fetch(url).then(WebAssembly.compileStreaming);
@@ -226,7 +226,7 @@ const captureTable5= new Map();
226
226
  let captureCnt5 = 0;
227
227
  handleTables[5] = handleTable5;
228
228
 
229
- function trampoline12(arg0, arg1, arg2) {
229
+ function trampoline12(arg0, arg1) {
230
230
  var handle1 = arg0;
231
231
  var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
232
232
  var rsc0 = captureTable5.get(rep2);
@@ -238,7 +238,7 @@ function trampoline12(arg0, arg1, arg2) {
238
238
  curResourceBorrows.push(rsc0);
239
239
  let ret;
240
240
  try {
241
- ret = { tag: 'ok', val: rsc0.readViaStream(BigInt.asUintN(64, arg1))};
241
+ ret = { tag: 'ok', val: rsc0.getType()};
242
242
  } catch (e) {
243
243
  ret = { tag: 'err', val: getErrorPayload(e) };
244
244
  }
@@ -250,22 +250,56 @@ function trampoline12(arg0, arg1, arg2) {
250
250
  switch (variant5.tag) {
251
251
  case 'ok': {
252
252
  const e = variant5.val;
253
- dataView(memory0).setInt8(arg2 + 0, 0, true);
254
- if (!(e instanceof InputStream)) {
255
- throw new TypeError('Resource error: Not a valid "InputStream" resource.');
256
- }
257
- var handle3 = e[symbolRscHandle];
258
- if (!handle3) {
259
- const rep = e[symbolRscRep] || ++captureCnt1;
260
- captureTable1.set(rep, e);
261
- handle3 = rscTableCreateOwn(handleTable1, rep);
253
+ dataView(memory0).setInt8(arg1 + 0, 0, true);
254
+ var val3 = e;
255
+ let enum3;
256
+ switch (val3) {
257
+ case 'unknown': {
258
+ enum3 = 0;
259
+ break;
260
+ }
261
+ case 'block-device': {
262
+ enum3 = 1;
263
+ break;
264
+ }
265
+ case 'character-device': {
266
+ enum3 = 2;
267
+ break;
268
+ }
269
+ case 'directory': {
270
+ enum3 = 3;
271
+ break;
272
+ }
273
+ case 'fifo': {
274
+ enum3 = 4;
275
+ break;
276
+ }
277
+ case 'symbolic-link': {
278
+ enum3 = 5;
279
+ break;
280
+ }
281
+ case 'regular-file': {
282
+ enum3 = 6;
283
+ break;
284
+ }
285
+ case 'socket': {
286
+ enum3 = 7;
287
+ break;
288
+ }
289
+ default: {
290
+ if ((e) instanceof Error) {
291
+ console.error(e);
292
+ }
293
+
294
+ throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
295
+ }
262
296
  }
263
- dataView(memory0).setInt32(arg2 + 4, handle3, true);
297
+ dataView(memory0).setInt8(arg1 + 1, enum3, true);
264
298
  break;
265
299
  }
266
300
  case 'err': {
267
301
  const e = variant5.val;
268
- dataView(memory0).setInt8(arg2 + 0, 1, true);
302
+ dataView(memory0).setInt8(arg1 + 0, 1, true);
269
303
  var val4 = e;
270
304
  let enum4;
271
305
  switch (val4) {
@@ -425,7 +459,7 @@ function trampoline12(arg0, arg1, arg2) {
425
459
  throw new TypeError(`"${val4}" is not one of the cases of error-code`);
426
460
  }
427
461
  }
428
- dataView(memory0).setInt8(arg2 + 4, enum4, true);
462
+ dataView(memory0).setInt8(arg1 + 1, enum4, true);
429
463
  break;
430
464
  }
431
465
  default: {
@@ -434,7 +468,7 @@ function trampoline12(arg0, arg1, arg2) {
434
468
  }
435
469
  }
436
470
 
437
- function trampoline13(arg0, arg1, arg2) {
471
+ function trampoline13(arg0, arg1) {
438
472
  var handle1 = arg0;
439
473
  var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
440
474
  var rsc0 = captureTable5.get(rep2);
@@ -446,7 +480,7 @@ function trampoline13(arg0, arg1, arg2) {
446
480
  curResourceBorrows.push(rsc0);
447
481
  let ret;
448
482
  try {
449
- ret = { tag: 'ok', val: rsc0.writeViaStream(BigInt.asUintN(64, arg1))};
483
+ ret = { tag: 'ok', val: rsc0.metadataHash()};
450
484
  } catch (e) {
451
485
  ret = { tag: 'err', val: getErrorPayload(e) };
452
486
  }
@@ -458,22 +492,15 @@ function trampoline13(arg0, arg1, arg2) {
458
492
  switch (variant5.tag) {
459
493
  case 'ok': {
460
494
  const e = variant5.val;
461
- dataView(memory0).setInt8(arg2 + 0, 0, true);
462
- if (!(e instanceof OutputStream)) {
463
- throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
464
- }
465
- var handle3 = e[symbolRscHandle];
466
- if (!handle3) {
467
- const rep = e[symbolRscRep] || ++captureCnt2;
468
- captureTable2.set(rep, e);
469
- handle3 = rscTableCreateOwn(handleTable2, rep);
470
- }
471
- dataView(memory0).setInt32(arg2 + 4, handle3, true);
495
+ dataView(memory0).setInt8(arg1 + 0, 0, true);
496
+ var {lower: v3_0, upper: v3_1 } = e;
497
+ dataView(memory0).setBigInt64(arg1 + 8, toUint64(v3_0), true);
498
+ dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
472
499
  break;
473
500
  }
474
501
  case 'err': {
475
502
  const e = variant5.val;
476
- dataView(memory0).setInt8(arg2 + 0, 1, true);
503
+ dataView(memory0).setInt8(arg1 + 0, 1, true);
477
504
  var val4 = e;
478
505
  let enum4;
479
506
  switch (val4) {
@@ -633,7 +660,7 @@ function trampoline13(arg0, arg1, arg2) {
633
660
  throw new TypeError(`"${val4}" is not one of the cases of error-code`);
634
661
  }
635
662
  }
636
- dataView(memory0).setInt8(arg2 + 4, enum4, true);
663
+ dataView(memory0).setInt8(arg1 + 8, enum4, true);
637
664
  break;
638
665
  }
639
666
  default: {
@@ -849,246 +876,192 @@ function trampoline14(arg0, arg1) {
849
876
  }
850
877
  }
851
878
  }
879
+ const handleTable0 = [T_FLAG, 0];
880
+ const captureTable0= new Map();
881
+ let captureCnt0 = 0;
882
+ handleTables[0] = handleTable0;
852
883
 
853
884
  function trampoline15(arg0, arg1) {
854
885
  var handle1 = arg0;
855
- var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
856
- var rsc0 = captureTable5.get(rep2);
886
+ var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
887
+ var rsc0 = captureTable0.get(rep2);
857
888
  if (!rsc0) {
858
- rsc0 = Object.create(Descriptor.prototype);
889
+ rsc0 = Object.create(Error$1.prototype);
859
890
  Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
860
891
  Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
861
892
  }
862
893
  curResourceBorrows.push(rsc0);
863
- let ret;
864
- try {
865
- ret = { tag: 'ok', val: rsc0.getType()};
866
- } catch (e) {
867
- ret = { tag: 'err', val: getErrorPayload(e) };
868
- }
894
+ const ret = filesystemErrorCode(rsc0);
869
895
  for (const rsc of curResourceBorrows) {
870
896
  rsc[symbolRscHandle] = null;
871
897
  }
872
898
  curResourceBorrows = [];
873
- var variant5 = ret;
874
- switch (variant5.tag) {
875
- case 'ok': {
876
- const e = variant5.val;
877
- dataView(memory0).setInt8(arg1 + 0, 0, true);
878
- var val3 = e;
879
- let enum3;
880
- switch (val3) {
881
- case 'unknown': {
882
- enum3 = 0;
883
- break;
884
- }
885
- case 'block-device': {
886
- enum3 = 1;
887
- break;
888
- }
889
- case 'character-device': {
890
- enum3 = 2;
891
- break;
892
- }
893
- case 'directory': {
894
- enum3 = 3;
895
- break;
896
- }
897
- case 'fifo': {
898
- enum3 = 4;
899
- break;
900
- }
901
- case 'symbolic-link': {
902
- enum3 = 5;
903
- break;
904
- }
905
- case 'regular-file': {
906
- enum3 = 6;
907
- break;
908
- }
909
- case 'socket': {
910
- enum3 = 7;
911
- break;
912
- }
913
- default: {
914
- if ((e) instanceof Error) {
915
- console.error(e);
916
- }
917
-
918
- throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
919
- }
899
+ var variant4 = ret;
900
+ if (variant4 === null || variant4=== undefined) {
901
+ dataView(memory0).setInt8(arg1 + 0, 0, true);
902
+ } else {
903
+ const e = variant4;
904
+ dataView(memory0).setInt8(arg1 + 0, 1, true);
905
+ var val3 = e;
906
+ let enum3;
907
+ switch (val3) {
908
+ case 'access': {
909
+ enum3 = 0;
910
+ break;
920
911
  }
921
- dataView(memory0).setInt8(arg1 + 1, enum3, true);
922
- break;
923
- }
924
- case 'err': {
925
- const e = variant5.val;
926
- dataView(memory0).setInt8(arg1 + 0, 1, true);
927
- var val4 = e;
928
- let enum4;
929
- switch (val4) {
930
- case 'access': {
931
- enum4 = 0;
932
- break;
933
- }
934
- case 'would-block': {
935
- enum4 = 1;
936
- break;
937
- }
938
- case 'already': {
939
- enum4 = 2;
940
- break;
941
- }
942
- case 'bad-descriptor': {
943
- enum4 = 3;
944
- break;
945
- }
946
- case 'busy': {
947
- enum4 = 4;
948
- break;
949
- }
950
- case 'deadlock': {
951
- enum4 = 5;
952
- break;
953
- }
954
- case 'quota': {
955
- enum4 = 6;
956
- break;
957
- }
958
- case 'exist': {
959
- enum4 = 7;
960
- break;
961
- }
962
- case 'file-too-large': {
963
- enum4 = 8;
964
- break;
965
- }
966
- case 'illegal-byte-sequence': {
967
- enum4 = 9;
968
- break;
969
- }
970
- case 'in-progress': {
971
- enum4 = 10;
972
- break;
973
- }
974
- case 'interrupted': {
975
- enum4 = 11;
976
- break;
977
- }
978
- case 'invalid': {
979
- enum4 = 12;
980
- break;
981
- }
982
- case 'io': {
983
- enum4 = 13;
984
- break;
985
- }
986
- case 'is-directory': {
987
- enum4 = 14;
988
- break;
989
- }
990
- case 'loop': {
991
- enum4 = 15;
992
- break;
993
- }
994
- case 'too-many-links': {
995
- enum4 = 16;
996
- break;
997
- }
998
- case 'message-size': {
999
- enum4 = 17;
1000
- break;
1001
- }
1002
- case 'name-too-long': {
1003
- enum4 = 18;
1004
- break;
1005
- }
1006
- case 'no-device': {
1007
- enum4 = 19;
1008
- break;
1009
- }
1010
- case 'no-entry': {
1011
- enum4 = 20;
1012
- break;
1013
- }
1014
- case 'no-lock': {
1015
- enum4 = 21;
1016
- break;
1017
- }
1018
- case 'insufficient-memory': {
1019
- enum4 = 22;
1020
- break;
1021
- }
1022
- case 'insufficient-space': {
1023
- enum4 = 23;
1024
- break;
1025
- }
1026
- case 'not-directory': {
1027
- enum4 = 24;
1028
- break;
1029
- }
1030
- case 'not-empty': {
1031
- enum4 = 25;
1032
- break;
1033
- }
1034
- case 'not-recoverable': {
1035
- enum4 = 26;
1036
- break;
1037
- }
1038
- case 'unsupported': {
1039
- enum4 = 27;
1040
- break;
1041
- }
1042
- case 'no-tty': {
1043
- enum4 = 28;
1044
- break;
1045
- }
1046
- case 'no-such-device': {
1047
- enum4 = 29;
1048
- break;
1049
- }
1050
- case 'overflow': {
1051
- enum4 = 30;
1052
- break;
1053
- }
1054
- case 'not-permitted': {
1055
- enum4 = 31;
1056
- break;
1057
- }
1058
- case 'pipe': {
1059
- enum4 = 32;
1060
- break;
1061
- }
1062
- case 'read-only': {
1063
- enum4 = 33;
1064
- break;
1065
- }
1066
- case 'invalid-seek': {
1067
- enum4 = 34;
1068
- break;
1069
- }
1070
- case 'text-file-busy': {
1071
- enum4 = 35;
1072
- break;
1073
- }
1074
- case 'cross-device': {
1075
- enum4 = 36;
1076
- break;
1077
- }
1078
- default: {
1079
- if ((e) instanceof Error) {
1080
- console.error(e);
1081
- }
1082
-
1083
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
912
+ case 'would-block': {
913
+ enum3 = 1;
914
+ break;
915
+ }
916
+ case 'already': {
917
+ enum3 = 2;
918
+ break;
919
+ }
920
+ case 'bad-descriptor': {
921
+ enum3 = 3;
922
+ break;
923
+ }
924
+ case 'busy': {
925
+ enum3 = 4;
926
+ break;
927
+ }
928
+ case 'deadlock': {
929
+ enum3 = 5;
930
+ break;
931
+ }
932
+ case 'quota': {
933
+ enum3 = 6;
934
+ break;
935
+ }
936
+ case 'exist': {
937
+ enum3 = 7;
938
+ break;
939
+ }
940
+ case 'file-too-large': {
941
+ enum3 = 8;
942
+ break;
943
+ }
944
+ case 'illegal-byte-sequence': {
945
+ enum3 = 9;
946
+ break;
947
+ }
948
+ case 'in-progress': {
949
+ enum3 = 10;
950
+ break;
951
+ }
952
+ case 'interrupted': {
953
+ enum3 = 11;
954
+ break;
955
+ }
956
+ case 'invalid': {
957
+ enum3 = 12;
958
+ break;
959
+ }
960
+ case 'io': {
961
+ enum3 = 13;
962
+ break;
963
+ }
964
+ case 'is-directory': {
965
+ enum3 = 14;
966
+ break;
967
+ }
968
+ case 'loop': {
969
+ enum3 = 15;
970
+ break;
971
+ }
972
+ case 'too-many-links': {
973
+ enum3 = 16;
974
+ break;
975
+ }
976
+ case 'message-size': {
977
+ enum3 = 17;
978
+ break;
979
+ }
980
+ case 'name-too-long': {
981
+ enum3 = 18;
982
+ break;
983
+ }
984
+ case 'no-device': {
985
+ enum3 = 19;
986
+ break;
987
+ }
988
+ case 'no-entry': {
989
+ enum3 = 20;
990
+ break;
991
+ }
992
+ case 'no-lock': {
993
+ enum3 = 21;
994
+ break;
995
+ }
996
+ case 'insufficient-memory': {
997
+ enum3 = 22;
998
+ break;
999
+ }
1000
+ case 'insufficient-space': {
1001
+ enum3 = 23;
1002
+ break;
1003
+ }
1004
+ case 'not-directory': {
1005
+ enum3 = 24;
1006
+ break;
1007
+ }
1008
+ case 'not-empty': {
1009
+ enum3 = 25;
1010
+ break;
1011
+ }
1012
+ case 'not-recoverable': {
1013
+ enum3 = 26;
1014
+ break;
1015
+ }
1016
+ case 'unsupported': {
1017
+ enum3 = 27;
1018
+ break;
1019
+ }
1020
+ case 'no-tty': {
1021
+ enum3 = 28;
1022
+ break;
1023
+ }
1024
+ case 'no-such-device': {
1025
+ enum3 = 29;
1026
+ break;
1027
+ }
1028
+ case 'overflow': {
1029
+ enum3 = 30;
1030
+ break;
1031
+ }
1032
+ case 'not-permitted': {
1033
+ enum3 = 31;
1034
+ break;
1035
+ }
1036
+ case 'pipe': {
1037
+ enum3 = 32;
1038
+ break;
1039
+ }
1040
+ case 'read-only': {
1041
+ enum3 = 33;
1042
+ break;
1043
+ }
1044
+ case 'invalid-seek': {
1045
+ enum3 = 34;
1046
+ break;
1047
+ }
1048
+ case 'text-file-busy': {
1049
+ enum3 = 35;
1050
+ break;
1051
+ }
1052
+ case 'cross-device': {
1053
+ enum3 = 36;
1054
+ break;
1055
+ }
1056
+ default: {
1057
+ if ((e) instanceof Error) {
1058
+ console.error(e);
1084
1059
  }
1060
+
1061
+ throw new TypeError(`"${val3}" is not one of the cases of error-code`);
1085
1062
  }
1086
- dataView(memory0).setInt8(arg1 + 1, enum4, true);
1087
- break;
1088
- }
1089
- default: {
1090
- throw new TypeError('invalid variant specified for result');
1091
1063
  }
1064
+ dataView(memory0).setInt8(arg1 + 1, enum3, true);
1092
1065
  }
1093
1066
  }
1094
1067
  const handleTable6 = [T_FLAG, 0];
@@ -1304,7 +1277,7 @@ function trampoline16(arg0, arg1) {
1304
1277
  }
1305
1278
  }
1306
1279
 
1307
- function trampoline17(arg0, arg1) {
1280
+ function trampoline17(arg0, arg1, arg2, arg3, arg4) {
1308
1281
  var handle1 = arg0;
1309
1282
  var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1310
1283
  var rsc0 = captureTable5.get(rep2);
@@ -1314,9 +1287,18 @@ function trampoline17(arg0, arg1) {
1314
1287
  Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1315
1288
  }
1316
1289
  curResourceBorrows.push(rsc0);
1290
+ if ((arg1 & 4294967294) !== 0) {
1291
+ throw new TypeError('flags have extraneous bits set');
1292
+ }
1293
+ var flags3 = {
1294
+ symlinkFollow: Boolean(arg1 & 1),
1295
+ };
1296
+ var ptr4 = arg2;
1297
+ var len4 = arg3;
1298
+ var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
1317
1299
  let ret;
1318
1300
  try {
1319
- ret = { tag: 'ok', val: rsc0.stat()};
1301
+ ret = { tag: 'ok', val: rsc0.metadataHashAt(flags3, result4)};
1320
1302
  } catch (e) {
1321
1303
  ret = { tag: 'err', val: getErrorPayload(e) };
1322
1304
  }
@@ -1324,242 +1306,168 @@ function trampoline17(arg0, arg1) {
1324
1306
  rsc[symbolRscHandle] = null;
1325
1307
  }
1326
1308
  curResourceBorrows = [];
1327
- var variant12 = ret;
1328
- switch (variant12.tag) {
1309
+ var variant7 = ret;
1310
+ switch (variant7.tag) {
1329
1311
  case 'ok': {
1330
- const e = variant12.val;
1331
- dataView(memory0).setInt8(arg1 + 0, 0, true);
1332
- var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
1333
- var val4 = v3_0;
1334
- let enum4;
1335
- switch (val4) {
1336
- case 'unknown': {
1337
- enum4 = 0;
1338
- break;
1339
- }
1340
- case 'block-device': {
1341
- enum4 = 1;
1342
- break;
1343
- }
1344
- case 'character-device': {
1345
- enum4 = 2;
1346
- break;
1347
- }
1348
- case 'directory': {
1349
- enum4 = 3;
1350
- break;
1351
- }
1352
- case 'fifo': {
1353
- enum4 = 4;
1354
- break;
1355
- }
1356
- case 'symbolic-link': {
1357
- enum4 = 5;
1358
- break;
1359
- }
1360
- case 'regular-file': {
1361
- enum4 = 6;
1362
- break;
1363
- }
1364
- case 'socket': {
1365
- enum4 = 7;
1366
- break;
1367
- }
1368
- default: {
1369
- if ((v3_0) instanceof Error) {
1370
- console.error(v3_0);
1371
- }
1372
-
1373
- throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
1374
- }
1375
- }
1376
- dataView(memory0).setInt8(arg1 + 8, enum4, true);
1377
- dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
1378
- dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
1379
- var variant6 = v3_3;
1380
- if (variant6 === null || variant6=== undefined) {
1381
- dataView(memory0).setInt8(arg1 + 32, 0, true);
1382
- } else {
1383
- const e = variant6;
1384
- dataView(memory0).setInt8(arg1 + 32, 1, true);
1385
- var {seconds: v5_0, nanoseconds: v5_1 } = e;
1386
- dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
1387
- dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
1388
- }
1389
- var variant8 = v3_4;
1390
- if (variant8 === null || variant8=== undefined) {
1391
- dataView(memory0).setInt8(arg1 + 56, 0, true);
1392
- } else {
1393
- const e = variant8;
1394
- dataView(memory0).setInt8(arg1 + 56, 1, true);
1395
- var {seconds: v7_0, nanoseconds: v7_1 } = e;
1396
- dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
1397
- dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
1398
- }
1399
- var variant10 = v3_5;
1400
- if (variant10 === null || variant10=== undefined) {
1401
- dataView(memory0).setInt8(arg1 + 80, 0, true);
1402
- } else {
1403
- const e = variant10;
1404
- dataView(memory0).setInt8(arg1 + 80, 1, true);
1405
- var {seconds: v9_0, nanoseconds: v9_1 } = e;
1406
- dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
1407
- dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
1408
- }
1312
+ const e = variant7.val;
1313
+ dataView(memory0).setInt8(arg4 + 0, 0, true);
1314
+ var {lower: v5_0, upper: v5_1 } = e;
1315
+ dataView(memory0).setBigInt64(arg4 + 8, toUint64(v5_0), true);
1316
+ dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
1409
1317
  break;
1410
1318
  }
1411
1319
  case 'err': {
1412
- const e = variant12.val;
1413
- dataView(memory0).setInt8(arg1 + 0, 1, true);
1414
- var val11 = e;
1415
- let enum11;
1416
- switch (val11) {
1320
+ const e = variant7.val;
1321
+ dataView(memory0).setInt8(arg4 + 0, 1, true);
1322
+ var val6 = e;
1323
+ let enum6;
1324
+ switch (val6) {
1417
1325
  case 'access': {
1418
- enum11 = 0;
1326
+ enum6 = 0;
1419
1327
  break;
1420
1328
  }
1421
1329
  case 'would-block': {
1422
- enum11 = 1;
1330
+ enum6 = 1;
1423
1331
  break;
1424
1332
  }
1425
1333
  case 'already': {
1426
- enum11 = 2;
1334
+ enum6 = 2;
1427
1335
  break;
1428
1336
  }
1429
1337
  case 'bad-descriptor': {
1430
- enum11 = 3;
1338
+ enum6 = 3;
1431
1339
  break;
1432
1340
  }
1433
1341
  case 'busy': {
1434
- enum11 = 4;
1342
+ enum6 = 4;
1435
1343
  break;
1436
1344
  }
1437
1345
  case 'deadlock': {
1438
- enum11 = 5;
1346
+ enum6 = 5;
1439
1347
  break;
1440
1348
  }
1441
1349
  case 'quota': {
1442
- enum11 = 6;
1350
+ enum6 = 6;
1443
1351
  break;
1444
1352
  }
1445
1353
  case 'exist': {
1446
- enum11 = 7;
1354
+ enum6 = 7;
1447
1355
  break;
1448
1356
  }
1449
1357
  case 'file-too-large': {
1450
- enum11 = 8;
1358
+ enum6 = 8;
1451
1359
  break;
1452
1360
  }
1453
1361
  case 'illegal-byte-sequence': {
1454
- enum11 = 9;
1362
+ enum6 = 9;
1455
1363
  break;
1456
1364
  }
1457
1365
  case 'in-progress': {
1458
- enum11 = 10;
1366
+ enum6 = 10;
1459
1367
  break;
1460
1368
  }
1461
1369
  case 'interrupted': {
1462
- enum11 = 11;
1370
+ enum6 = 11;
1463
1371
  break;
1464
1372
  }
1465
1373
  case 'invalid': {
1466
- enum11 = 12;
1374
+ enum6 = 12;
1467
1375
  break;
1468
1376
  }
1469
1377
  case 'io': {
1470
- enum11 = 13;
1378
+ enum6 = 13;
1471
1379
  break;
1472
1380
  }
1473
1381
  case 'is-directory': {
1474
- enum11 = 14;
1382
+ enum6 = 14;
1475
1383
  break;
1476
1384
  }
1477
1385
  case 'loop': {
1478
- enum11 = 15;
1386
+ enum6 = 15;
1479
1387
  break;
1480
1388
  }
1481
1389
  case 'too-many-links': {
1482
- enum11 = 16;
1390
+ enum6 = 16;
1483
1391
  break;
1484
1392
  }
1485
1393
  case 'message-size': {
1486
- enum11 = 17;
1394
+ enum6 = 17;
1487
1395
  break;
1488
1396
  }
1489
1397
  case 'name-too-long': {
1490
- enum11 = 18;
1398
+ enum6 = 18;
1491
1399
  break;
1492
1400
  }
1493
1401
  case 'no-device': {
1494
- enum11 = 19;
1402
+ enum6 = 19;
1495
1403
  break;
1496
1404
  }
1497
1405
  case 'no-entry': {
1498
- enum11 = 20;
1406
+ enum6 = 20;
1499
1407
  break;
1500
1408
  }
1501
1409
  case 'no-lock': {
1502
- enum11 = 21;
1410
+ enum6 = 21;
1503
1411
  break;
1504
1412
  }
1505
1413
  case 'insufficient-memory': {
1506
- enum11 = 22;
1414
+ enum6 = 22;
1507
1415
  break;
1508
1416
  }
1509
1417
  case 'insufficient-space': {
1510
- enum11 = 23;
1418
+ enum6 = 23;
1511
1419
  break;
1512
1420
  }
1513
1421
  case 'not-directory': {
1514
- enum11 = 24;
1422
+ enum6 = 24;
1515
1423
  break;
1516
1424
  }
1517
1425
  case 'not-empty': {
1518
- enum11 = 25;
1426
+ enum6 = 25;
1519
1427
  break;
1520
1428
  }
1521
1429
  case 'not-recoverable': {
1522
- enum11 = 26;
1430
+ enum6 = 26;
1523
1431
  break;
1524
1432
  }
1525
1433
  case 'unsupported': {
1526
- enum11 = 27;
1434
+ enum6 = 27;
1527
1435
  break;
1528
1436
  }
1529
1437
  case 'no-tty': {
1530
- enum11 = 28;
1438
+ enum6 = 28;
1531
1439
  break;
1532
1440
  }
1533
1441
  case 'no-such-device': {
1534
- enum11 = 29;
1442
+ enum6 = 29;
1535
1443
  break;
1536
1444
  }
1537
1445
  case 'overflow': {
1538
- enum11 = 30;
1446
+ enum6 = 30;
1539
1447
  break;
1540
1448
  }
1541
1449
  case 'not-permitted': {
1542
- enum11 = 31;
1450
+ enum6 = 31;
1543
1451
  break;
1544
1452
  }
1545
1453
  case 'pipe': {
1546
- enum11 = 32;
1454
+ enum6 = 32;
1547
1455
  break;
1548
1456
  }
1549
1457
  case 'read-only': {
1550
- enum11 = 33;
1458
+ enum6 = 33;
1551
1459
  break;
1552
1460
  }
1553
1461
  case 'invalid-seek': {
1554
- enum11 = 34;
1462
+ enum6 = 34;
1555
1463
  break;
1556
1464
  }
1557
1465
  case 'text-file-busy': {
1558
- enum11 = 35;
1466
+ enum6 = 35;
1559
1467
  break;
1560
1468
  }
1561
1469
  case 'cross-device': {
1562
- enum11 = 36;
1470
+ enum6 = 36;
1563
1471
  break;
1564
1472
  }
1565
1473
  default: {
@@ -1567,10 +1475,10 @@ function trampoline17(arg0, arg1) {
1567
1475
  console.error(e);
1568
1476
  }
1569
1477
 
1570
- throw new TypeError(`"${val11}" is not one of the cases of error-code`);
1478
+ throw new TypeError(`"${val6}" is not one of the cases of error-code`);
1571
1479
  }
1572
1480
  }
1573
- dataView(memory0).setInt8(arg1 + 8, enum11, true);
1481
+ dataView(memory0).setInt8(arg4 + 8, enum6, true);
1574
1482
  break;
1575
1483
  }
1576
1484
  default: {
@@ -1579,7 +1487,7 @@ function trampoline17(arg0, arg1) {
1579
1487
  }
1580
1488
  }
1581
1489
 
1582
- function trampoline18(arg0, arg1, arg2, arg3, arg4) {
1490
+ function trampoline18(arg0, arg1, arg2) {
1583
1491
  var handle1 = arg0;
1584
1492
  var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1585
1493
  var rsc0 = captureTable5.get(rep2);
@@ -1589,18 +1497,9 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4) {
1589
1497
  Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1590
1498
  }
1591
1499
  curResourceBorrows.push(rsc0);
1592
- if ((arg1 & 4294967294) !== 0) {
1593
- throw new TypeError('flags have extraneous bits set');
1594
- }
1595
- var flags3 = {
1596
- symlinkFollow: Boolean(arg1 & 1),
1597
- };
1598
- var ptr4 = arg2;
1599
- var len4 = arg3;
1600
- var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
1601
1500
  let ret;
1602
1501
  try {
1603
- ret = { tag: 'ok', val: rsc0.statAt(flags3, result4)};
1502
+ ret = { tag: 'ok', val: rsc0.readViaStream(BigInt.asUintN(64, arg1))};
1604
1503
  } catch (e) {
1605
1504
  ret = { tag: 'err', val: getErrorPayload(e) };
1606
1505
  }
@@ -1608,242 +1507,175 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4) {
1608
1507
  rsc[symbolRscHandle] = null;
1609
1508
  }
1610
1509
  curResourceBorrows = [];
1611
- var variant14 = ret;
1612
- switch (variant14.tag) {
1510
+ var variant5 = ret;
1511
+ switch (variant5.tag) {
1613
1512
  case 'ok': {
1614
- const e = variant14.val;
1615
- dataView(memory0).setInt8(arg4 + 0, 0, true);
1616
- var {type: v5_0, linkCount: v5_1, size: v5_2, dataAccessTimestamp: v5_3, dataModificationTimestamp: v5_4, statusChangeTimestamp: v5_5 } = e;
1617
- var val6 = v5_0;
1618
- let enum6;
1619
- switch (val6) {
1620
- case 'unknown': {
1621
- enum6 = 0;
1513
+ const e = variant5.val;
1514
+ dataView(memory0).setInt8(arg2 + 0, 0, true);
1515
+ if (!(e instanceof InputStream)) {
1516
+ throw new TypeError('Resource error: Not a valid "InputStream" resource.');
1517
+ }
1518
+ var handle3 = e[symbolRscHandle];
1519
+ if (!handle3) {
1520
+ const rep = e[symbolRscRep] || ++captureCnt1;
1521
+ captureTable1.set(rep, e);
1522
+ handle3 = rscTableCreateOwn(handleTable1, rep);
1523
+ }
1524
+ dataView(memory0).setInt32(arg2 + 4, handle3, true);
1525
+ break;
1526
+ }
1527
+ case 'err': {
1528
+ const e = variant5.val;
1529
+ dataView(memory0).setInt8(arg2 + 0, 1, true);
1530
+ var val4 = e;
1531
+ let enum4;
1532
+ switch (val4) {
1533
+ case 'access': {
1534
+ enum4 = 0;
1622
1535
  break;
1623
1536
  }
1624
- case 'block-device': {
1625
- enum6 = 1;
1537
+ case 'would-block': {
1538
+ enum4 = 1;
1626
1539
  break;
1627
1540
  }
1628
- case 'character-device': {
1629
- enum6 = 2;
1541
+ case 'already': {
1542
+ enum4 = 2;
1630
1543
  break;
1631
1544
  }
1632
- case 'directory': {
1633
- enum6 = 3;
1545
+ case 'bad-descriptor': {
1546
+ enum4 = 3;
1634
1547
  break;
1635
1548
  }
1636
- case 'fifo': {
1637
- enum6 = 4;
1549
+ case 'busy': {
1550
+ enum4 = 4;
1638
1551
  break;
1639
1552
  }
1640
- case 'symbolic-link': {
1641
- enum6 = 5;
1553
+ case 'deadlock': {
1554
+ enum4 = 5;
1642
1555
  break;
1643
1556
  }
1644
- case 'regular-file': {
1645
- enum6 = 6;
1557
+ case 'quota': {
1558
+ enum4 = 6;
1646
1559
  break;
1647
1560
  }
1648
- case 'socket': {
1649
- enum6 = 7;
1561
+ case 'exist': {
1562
+ enum4 = 7;
1650
1563
  break;
1651
1564
  }
1652
- default: {
1653
- if ((v5_0) instanceof Error) {
1654
- console.error(v5_0);
1655
- }
1656
-
1657
- throw new TypeError(`"${val6}" is not one of the cases of descriptor-type`);
1658
- }
1659
- }
1660
- dataView(memory0).setInt8(arg4 + 8, enum6, true);
1661
- dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
1662
- dataView(memory0).setBigInt64(arg4 + 24, toUint64(v5_2), true);
1663
- var variant8 = v5_3;
1664
- if (variant8 === null || variant8=== undefined) {
1665
- dataView(memory0).setInt8(arg4 + 32, 0, true);
1666
- } else {
1667
- const e = variant8;
1668
- dataView(memory0).setInt8(arg4 + 32, 1, true);
1669
- var {seconds: v7_0, nanoseconds: v7_1 } = e;
1670
- dataView(memory0).setBigInt64(arg4 + 40, toUint64(v7_0), true);
1671
- dataView(memory0).setInt32(arg4 + 48, toUint32(v7_1), true);
1672
- }
1673
- var variant10 = v5_4;
1674
- if (variant10 === null || variant10=== undefined) {
1675
- dataView(memory0).setInt8(arg4 + 56, 0, true);
1676
- } else {
1677
- const e = variant10;
1678
- dataView(memory0).setInt8(arg4 + 56, 1, true);
1679
- var {seconds: v9_0, nanoseconds: v9_1 } = e;
1680
- dataView(memory0).setBigInt64(arg4 + 64, toUint64(v9_0), true);
1681
- dataView(memory0).setInt32(arg4 + 72, toUint32(v9_1), true);
1682
- }
1683
- var variant12 = v5_5;
1684
- if (variant12 === null || variant12=== undefined) {
1685
- dataView(memory0).setInt8(arg4 + 80, 0, true);
1686
- } else {
1687
- const e = variant12;
1688
- dataView(memory0).setInt8(arg4 + 80, 1, true);
1689
- var {seconds: v11_0, nanoseconds: v11_1 } = e;
1690
- dataView(memory0).setBigInt64(arg4 + 88, toUint64(v11_0), true);
1691
- dataView(memory0).setInt32(arg4 + 96, toUint32(v11_1), true);
1692
- }
1693
- break;
1694
- }
1695
- case 'err': {
1696
- const e = variant14.val;
1697
- dataView(memory0).setInt8(arg4 + 0, 1, true);
1698
- var val13 = e;
1699
- let enum13;
1700
- switch (val13) {
1701
- case 'access': {
1702
- enum13 = 0;
1703
- break;
1704
- }
1705
- case 'would-block': {
1706
- enum13 = 1;
1707
- break;
1708
- }
1709
- case 'already': {
1710
- enum13 = 2;
1711
- break;
1712
- }
1713
- case 'bad-descriptor': {
1714
- enum13 = 3;
1715
- break;
1716
- }
1717
- case 'busy': {
1718
- enum13 = 4;
1719
- break;
1720
- }
1721
- case 'deadlock': {
1722
- enum13 = 5;
1723
- break;
1724
- }
1725
- case 'quota': {
1726
- enum13 = 6;
1727
- break;
1728
- }
1729
- case 'exist': {
1730
- enum13 = 7;
1731
- break;
1732
- }
1733
- case 'file-too-large': {
1734
- enum13 = 8;
1735
- break;
1565
+ case 'file-too-large': {
1566
+ enum4 = 8;
1567
+ break;
1736
1568
  }
1737
1569
  case 'illegal-byte-sequence': {
1738
- enum13 = 9;
1570
+ enum4 = 9;
1739
1571
  break;
1740
1572
  }
1741
1573
  case 'in-progress': {
1742
- enum13 = 10;
1574
+ enum4 = 10;
1743
1575
  break;
1744
1576
  }
1745
1577
  case 'interrupted': {
1746
- enum13 = 11;
1578
+ enum4 = 11;
1747
1579
  break;
1748
1580
  }
1749
1581
  case 'invalid': {
1750
- enum13 = 12;
1582
+ enum4 = 12;
1751
1583
  break;
1752
1584
  }
1753
1585
  case 'io': {
1754
- enum13 = 13;
1586
+ enum4 = 13;
1755
1587
  break;
1756
1588
  }
1757
1589
  case 'is-directory': {
1758
- enum13 = 14;
1590
+ enum4 = 14;
1759
1591
  break;
1760
1592
  }
1761
1593
  case 'loop': {
1762
- enum13 = 15;
1594
+ enum4 = 15;
1763
1595
  break;
1764
1596
  }
1765
1597
  case 'too-many-links': {
1766
- enum13 = 16;
1598
+ enum4 = 16;
1767
1599
  break;
1768
1600
  }
1769
1601
  case 'message-size': {
1770
- enum13 = 17;
1602
+ enum4 = 17;
1771
1603
  break;
1772
1604
  }
1773
1605
  case 'name-too-long': {
1774
- enum13 = 18;
1606
+ enum4 = 18;
1775
1607
  break;
1776
1608
  }
1777
1609
  case 'no-device': {
1778
- enum13 = 19;
1610
+ enum4 = 19;
1779
1611
  break;
1780
1612
  }
1781
1613
  case 'no-entry': {
1782
- enum13 = 20;
1614
+ enum4 = 20;
1783
1615
  break;
1784
1616
  }
1785
1617
  case 'no-lock': {
1786
- enum13 = 21;
1618
+ enum4 = 21;
1787
1619
  break;
1788
1620
  }
1789
1621
  case 'insufficient-memory': {
1790
- enum13 = 22;
1622
+ enum4 = 22;
1791
1623
  break;
1792
1624
  }
1793
1625
  case 'insufficient-space': {
1794
- enum13 = 23;
1626
+ enum4 = 23;
1795
1627
  break;
1796
1628
  }
1797
1629
  case 'not-directory': {
1798
- enum13 = 24;
1630
+ enum4 = 24;
1799
1631
  break;
1800
1632
  }
1801
1633
  case 'not-empty': {
1802
- enum13 = 25;
1634
+ enum4 = 25;
1803
1635
  break;
1804
1636
  }
1805
1637
  case 'not-recoverable': {
1806
- enum13 = 26;
1638
+ enum4 = 26;
1807
1639
  break;
1808
1640
  }
1809
1641
  case 'unsupported': {
1810
- enum13 = 27;
1642
+ enum4 = 27;
1811
1643
  break;
1812
1644
  }
1813
1645
  case 'no-tty': {
1814
- enum13 = 28;
1646
+ enum4 = 28;
1815
1647
  break;
1816
1648
  }
1817
1649
  case 'no-such-device': {
1818
- enum13 = 29;
1650
+ enum4 = 29;
1819
1651
  break;
1820
1652
  }
1821
1653
  case 'overflow': {
1822
- enum13 = 30;
1654
+ enum4 = 30;
1823
1655
  break;
1824
1656
  }
1825
1657
  case 'not-permitted': {
1826
- enum13 = 31;
1658
+ enum4 = 31;
1827
1659
  break;
1828
1660
  }
1829
1661
  case 'pipe': {
1830
- enum13 = 32;
1662
+ enum4 = 32;
1831
1663
  break;
1832
1664
  }
1833
1665
  case 'read-only': {
1834
- enum13 = 33;
1666
+ enum4 = 33;
1835
1667
  break;
1836
1668
  }
1837
1669
  case 'invalid-seek': {
1838
- enum13 = 34;
1670
+ enum4 = 34;
1839
1671
  break;
1840
1672
  }
1841
1673
  case 'text-file-busy': {
1842
- enum13 = 35;
1674
+ enum4 = 35;
1843
1675
  break;
1844
1676
  }
1845
1677
  case 'cross-device': {
1846
- enum13 = 36;
1678
+ enum4 = 36;
1847
1679
  break;
1848
1680
  }
1849
1681
  default: {
@@ -1851,10 +1683,10 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4) {
1851
1683
  console.error(e);
1852
1684
  }
1853
1685
 
1854
- throw new TypeError(`"${val13}" is not one of the cases of error-code`);
1686
+ throw new TypeError(`"${val4}" is not one of the cases of error-code`);
1855
1687
  }
1856
1688
  }
1857
- dataView(memory0).setInt8(arg4 + 8, enum13, true);
1689
+ dataView(memory0).setInt8(arg2 + 4, enum4, true);
1858
1690
  break;
1859
1691
  }
1860
1692
  default: {
@@ -1863,7 +1695,7 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4) {
1863
1695
  }
1864
1696
  }
1865
1697
 
1866
- function trampoline19(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
1698
+ function trampoline19(arg0, arg1, arg2) {
1867
1699
  var handle1 = arg0;
1868
1700
  var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
1869
1701
  var rsc0 = captureTable5.get(rep2);
@@ -1873,38 +1705,9 @@ function trampoline19(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
1873
1705
  Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
1874
1706
  }
1875
1707
  curResourceBorrows.push(rsc0);
1876
- if ((arg1 & 4294967294) !== 0) {
1877
- throw new TypeError('flags have extraneous bits set');
1878
- }
1879
- var flags3 = {
1880
- symlinkFollow: Boolean(arg1 & 1),
1881
- };
1882
- var ptr4 = arg2;
1883
- var len4 = arg3;
1884
- var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
1885
- if ((arg4 & 4294967280) !== 0) {
1886
- throw new TypeError('flags have extraneous bits set');
1887
- }
1888
- var flags5 = {
1889
- create: Boolean(arg4 & 1),
1890
- directory: Boolean(arg4 & 2),
1891
- exclusive: Boolean(arg4 & 4),
1892
- truncate: Boolean(arg4 & 8),
1893
- };
1894
- if ((arg5 & 4294967232) !== 0) {
1895
- throw new TypeError('flags have extraneous bits set');
1896
- }
1897
- var flags6 = {
1898
- read: Boolean(arg5 & 1),
1899
- write: Boolean(arg5 & 2),
1900
- fileIntegritySync: Boolean(arg5 & 4),
1901
- dataIntegritySync: Boolean(arg5 & 8),
1902
- requestedWriteSync: Boolean(arg5 & 16),
1903
- mutateDirectory: Boolean(arg5 & 32),
1904
- };
1905
1708
  let ret;
1906
1709
  try {
1907
- ret = { tag: 'ok', val: rsc0.openAt(flags3, result4, flags5, flags6)};
1710
+ ret = { tag: 'ok', val: rsc0.writeViaStream(BigInt.asUintN(64, arg1))};
1908
1711
  } catch (e) {
1909
1712
  ret = { tag: 'err', val: getErrorPayload(e) };
1910
1713
  }
@@ -1912,175 +1715,175 @@ function trampoline19(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
1912
1715
  rsc[symbolRscHandle] = null;
1913
1716
  }
1914
1717
  curResourceBorrows = [];
1915
- var variant9 = ret;
1916
- switch (variant9.tag) {
1718
+ var variant5 = ret;
1719
+ switch (variant5.tag) {
1917
1720
  case 'ok': {
1918
- const e = variant9.val;
1919
- dataView(memory0).setInt8(arg6 + 0, 0, true);
1920
- if (!(e instanceof Descriptor)) {
1921
- throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
1721
+ const e = variant5.val;
1722
+ dataView(memory0).setInt8(arg2 + 0, 0, true);
1723
+ if (!(e instanceof OutputStream)) {
1724
+ throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
1922
1725
  }
1923
- var handle7 = e[symbolRscHandle];
1924
- if (!handle7) {
1925
- const rep = e[symbolRscRep] || ++captureCnt5;
1926
- captureTable5.set(rep, e);
1927
- handle7 = rscTableCreateOwn(handleTable5, rep);
1726
+ var handle3 = e[symbolRscHandle];
1727
+ if (!handle3) {
1728
+ const rep = e[symbolRscRep] || ++captureCnt2;
1729
+ captureTable2.set(rep, e);
1730
+ handle3 = rscTableCreateOwn(handleTable2, rep);
1928
1731
  }
1929
- dataView(memory0).setInt32(arg6 + 4, handle7, true);
1732
+ dataView(memory0).setInt32(arg2 + 4, handle3, true);
1930
1733
  break;
1931
1734
  }
1932
1735
  case 'err': {
1933
- const e = variant9.val;
1934
- dataView(memory0).setInt8(arg6 + 0, 1, true);
1935
- var val8 = e;
1936
- let enum8;
1937
- switch (val8) {
1736
+ const e = variant5.val;
1737
+ dataView(memory0).setInt8(arg2 + 0, 1, true);
1738
+ var val4 = e;
1739
+ let enum4;
1740
+ switch (val4) {
1938
1741
  case 'access': {
1939
- enum8 = 0;
1742
+ enum4 = 0;
1940
1743
  break;
1941
1744
  }
1942
1745
  case 'would-block': {
1943
- enum8 = 1;
1746
+ enum4 = 1;
1944
1747
  break;
1945
1748
  }
1946
1749
  case 'already': {
1947
- enum8 = 2;
1750
+ enum4 = 2;
1948
1751
  break;
1949
1752
  }
1950
1753
  case 'bad-descriptor': {
1951
- enum8 = 3;
1754
+ enum4 = 3;
1952
1755
  break;
1953
1756
  }
1954
1757
  case 'busy': {
1955
- enum8 = 4;
1758
+ enum4 = 4;
1956
1759
  break;
1957
1760
  }
1958
1761
  case 'deadlock': {
1959
- enum8 = 5;
1762
+ enum4 = 5;
1960
1763
  break;
1961
1764
  }
1962
1765
  case 'quota': {
1963
- enum8 = 6;
1766
+ enum4 = 6;
1964
1767
  break;
1965
1768
  }
1966
1769
  case 'exist': {
1967
- enum8 = 7;
1770
+ enum4 = 7;
1968
1771
  break;
1969
1772
  }
1970
1773
  case 'file-too-large': {
1971
- enum8 = 8;
1774
+ enum4 = 8;
1972
1775
  break;
1973
1776
  }
1974
1777
  case 'illegal-byte-sequence': {
1975
- enum8 = 9;
1778
+ enum4 = 9;
1976
1779
  break;
1977
1780
  }
1978
1781
  case 'in-progress': {
1979
- enum8 = 10;
1782
+ enum4 = 10;
1980
1783
  break;
1981
1784
  }
1982
1785
  case 'interrupted': {
1983
- enum8 = 11;
1786
+ enum4 = 11;
1984
1787
  break;
1985
1788
  }
1986
1789
  case 'invalid': {
1987
- enum8 = 12;
1790
+ enum4 = 12;
1988
1791
  break;
1989
1792
  }
1990
1793
  case 'io': {
1991
- enum8 = 13;
1794
+ enum4 = 13;
1992
1795
  break;
1993
1796
  }
1994
1797
  case 'is-directory': {
1995
- enum8 = 14;
1798
+ enum4 = 14;
1996
1799
  break;
1997
1800
  }
1998
1801
  case 'loop': {
1999
- enum8 = 15;
1802
+ enum4 = 15;
2000
1803
  break;
2001
1804
  }
2002
1805
  case 'too-many-links': {
2003
- enum8 = 16;
1806
+ enum4 = 16;
2004
1807
  break;
2005
1808
  }
2006
1809
  case 'message-size': {
2007
- enum8 = 17;
1810
+ enum4 = 17;
2008
1811
  break;
2009
1812
  }
2010
1813
  case 'name-too-long': {
2011
- enum8 = 18;
1814
+ enum4 = 18;
2012
1815
  break;
2013
1816
  }
2014
1817
  case 'no-device': {
2015
- enum8 = 19;
1818
+ enum4 = 19;
2016
1819
  break;
2017
1820
  }
2018
1821
  case 'no-entry': {
2019
- enum8 = 20;
1822
+ enum4 = 20;
2020
1823
  break;
2021
1824
  }
2022
1825
  case 'no-lock': {
2023
- enum8 = 21;
1826
+ enum4 = 21;
2024
1827
  break;
2025
1828
  }
2026
1829
  case 'insufficient-memory': {
2027
- enum8 = 22;
1830
+ enum4 = 22;
2028
1831
  break;
2029
1832
  }
2030
1833
  case 'insufficient-space': {
2031
- enum8 = 23;
1834
+ enum4 = 23;
2032
1835
  break;
2033
1836
  }
2034
1837
  case 'not-directory': {
2035
- enum8 = 24;
1838
+ enum4 = 24;
2036
1839
  break;
2037
1840
  }
2038
1841
  case 'not-empty': {
2039
- enum8 = 25;
1842
+ enum4 = 25;
2040
1843
  break;
2041
1844
  }
2042
1845
  case 'not-recoverable': {
2043
- enum8 = 26;
1846
+ enum4 = 26;
2044
1847
  break;
2045
1848
  }
2046
1849
  case 'unsupported': {
2047
- enum8 = 27;
1850
+ enum4 = 27;
2048
1851
  break;
2049
1852
  }
2050
1853
  case 'no-tty': {
2051
- enum8 = 28;
1854
+ enum4 = 28;
2052
1855
  break;
2053
1856
  }
2054
1857
  case 'no-such-device': {
2055
- enum8 = 29;
1858
+ enum4 = 29;
2056
1859
  break;
2057
1860
  }
2058
1861
  case 'overflow': {
2059
- enum8 = 30;
1862
+ enum4 = 30;
2060
1863
  break;
2061
1864
  }
2062
1865
  case 'not-permitted': {
2063
- enum8 = 31;
1866
+ enum4 = 31;
2064
1867
  break;
2065
1868
  }
2066
1869
  case 'pipe': {
2067
- enum8 = 32;
1870
+ enum4 = 32;
2068
1871
  break;
2069
1872
  }
2070
1873
  case 'read-only': {
2071
- enum8 = 33;
1874
+ enum4 = 33;
2072
1875
  break;
2073
1876
  }
2074
1877
  case 'invalid-seek': {
2075
- enum8 = 34;
1878
+ enum4 = 34;
2076
1879
  break;
2077
1880
  }
2078
1881
  case 'text-file-busy': {
2079
- enum8 = 35;
1882
+ enum4 = 35;
2080
1883
  break;
2081
1884
  }
2082
1885
  case 'cross-device': {
2083
- enum8 = 36;
1886
+ enum4 = 36;
2084
1887
  break;
2085
1888
  }
2086
1889
  default: {
@@ -2088,10 +1891,10 @@ function trampoline19(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
2088
1891
  console.error(e);
2089
1892
  }
2090
1893
 
2091
- throw new TypeError(`"${val8}" is not one of the cases of error-code`);
1894
+ throw new TypeError(`"${val4}" is not one of the cases of error-code`);
2092
1895
  }
2093
1896
  }
2094
- dataView(memory0).setInt8(arg6 + 4, enum8, true);
1897
+ dataView(memory0).setInt8(arg2 + 4, enum4, true);
2095
1898
  break;
2096
1899
  }
2097
1900
  default: {
@@ -2112,7 +1915,7 @@ function trampoline20(arg0, arg1) {
2112
1915
  curResourceBorrows.push(rsc0);
2113
1916
  let ret;
2114
1917
  try {
2115
- ret = { tag: 'ok', val: rsc0.metadataHash()};
1918
+ ret = { tag: 'ok', val: rsc0.stat()};
2116
1919
  } catch (e) {
2117
1920
  ret = { tag: 'err', val: getErrorPayload(e) };
2118
1921
  }
@@ -2120,168 +1923,526 @@ function trampoline20(arg0, arg1) {
2120
1923
  rsc[symbolRscHandle] = null;
2121
1924
  }
2122
1925
  curResourceBorrows = [];
2123
- var variant5 = ret;
2124
- switch (variant5.tag) {
1926
+ var variant12 = ret;
1927
+ switch (variant12.tag) {
2125
1928
  case 'ok': {
2126
- const e = variant5.val;
1929
+ const e = variant12.val;
2127
1930
  dataView(memory0).setInt8(arg1 + 0, 0, true);
2128
- var {lower: v3_0, upper: v3_1 } = e;
2129
- dataView(memory0).setBigInt64(arg1 + 8, toUint64(v3_0), true);
1931
+ var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
1932
+ var val4 = v3_0;
1933
+ let enum4;
1934
+ switch (val4) {
1935
+ case 'unknown': {
1936
+ enum4 = 0;
1937
+ break;
1938
+ }
1939
+ case 'block-device': {
1940
+ enum4 = 1;
1941
+ break;
1942
+ }
1943
+ case 'character-device': {
1944
+ enum4 = 2;
1945
+ break;
1946
+ }
1947
+ case 'directory': {
1948
+ enum4 = 3;
1949
+ break;
1950
+ }
1951
+ case 'fifo': {
1952
+ enum4 = 4;
1953
+ break;
1954
+ }
1955
+ case 'symbolic-link': {
1956
+ enum4 = 5;
1957
+ break;
1958
+ }
1959
+ case 'regular-file': {
1960
+ enum4 = 6;
1961
+ break;
1962
+ }
1963
+ case 'socket': {
1964
+ enum4 = 7;
1965
+ break;
1966
+ }
1967
+ default: {
1968
+ if ((v3_0) instanceof Error) {
1969
+ console.error(v3_0);
1970
+ }
1971
+
1972
+ throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
1973
+ }
1974
+ }
1975
+ dataView(memory0).setInt8(arg1 + 8, enum4, true);
2130
1976
  dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
1977
+ dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
1978
+ var variant6 = v3_3;
1979
+ if (variant6 === null || variant6=== undefined) {
1980
+ dataView(memory0).setInt8(arg1 + 32, 0, true);
1981
+ } else {
1982
+ const e = variant6;
1983
+ dataView(memory0).setInt8(arg1 + 32, 1, true);
1984
+ var {seconds: v5_0, nanoseconds: v5_1 } = e;
1985
+ dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
1986
+ dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
1987
+ }
1988
+ var variant8 = v3_4;
1989
+ if (variant8 === null || variant8=== undefined) {
1990
+ dataView(memory0).setInt8(arg1 + 56, 0, true);
1991
+ } else {
1992
+ const e = variant8;
1993
+ dataView(memory0).setInt8(arg1 + 56, 1, true);
1994
+ var {seconds: v7_0, nanoseconds: v7_1 } = e;
1995
+ dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
1996
+ dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
1997
+ }
1998
+ var variant10 = v3_5;
1999
+ if (variant10 === null || variant10=== undefined) {
2000
+ dataView(memory0).setInt8(arg1 + 80, 0, true);
2001
+ } else {
2002
+ const e = variant10;
2003
+ dataView(memory0).setInt8(arg1 + 80, 1, true);
2004
+ var {seconds: v9_0, nanoseconds: v9_1 } = e;
2005
+ dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
2006
+ dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
2007
+ }
2008
+ break;
2009
+ }
2010
+ case 'err': {
2011
+ const e = variant12.val;
2012
+ dataView(memory0).setInt8(arg1 + 0, 1, true);
2013
+ var val11 = e;
2014
+ let enum11;
2015
+ switch (val11) {
2016
+ case 'access': {
2017
+ enum11 = 0;
2018
+ break;
2019
+ }
2020
+ case 'would-block': {
2021
+ enum11 = 1;
2022
+ break;
2023
+ }
2024
+ case 'already': {
2025
+ enum11 = 2;
2026
+ break;
2027
+ }
2028
+ case 'bad-descriptor': {
2029
+ enum11 = 3;
2030
+ break;
2031
+ }
2032
+ case 'busy': {
2033
+ enum11 = 4;
2034
+ break;
2035
+ }
2036
+ case 'deadlock': {
2037
+ enum11 = 5;
2038
+ break;
2039
+ }
2040
+ case 'quota': {
2041
+ enum11 = 6;
2042
+ break;
2043
+ }
2044
+ case 'exist': {
2045
+ enum11 = 7;
2046
+ break;
2047
+ }
2048
+ case 'file-too-large': {
2049
+ enum11 = 8;
2050
+ break;
2051
+ }
2052
+ case 'illegal-byte-sequence': {
2053
+ enum11 = 9;
2054
+ break;
2055
+ }
2056
+ case 'in-progress': {
2057
+ enum11 = 10;
2058
+ break;
2059
+ }
2060
+ case 'interrupted': {
2061
+ enum11 = 11;
2062
+ break;
2063
+ }
2064
+ case 'invalid': {
2065
+ enum11 = 12;
2066
+ break;
2067
+ }
2068
+ case 'io': {
2069
+ enum11 = 13;
2070
+ break;
2071
+ }
2072
+ case 'is-directory': {
2073
+ enum11 = 14;
2074
+ break;
2075
+ }
2076
+ case 'loop': {
2077
+ enum11 = 15;
2078
+ break;
2079
+ }
2080
+ case 'too-many-links': {
2081
+ enum11 = 16;
2082
+ break;
2083
+ }
2084
+ case 'message-size': {
2085
+ enum11 = 17;
2086
+ break;
2087
+ }
2088
+ case 'name-too-long': {
2089
+ enum11 = 18;
2090
+ break;
2091
+ }
2092
+ case 'no-device': {
2093
+ enum11 = 19;
2094
+ break;
2095
+ }
2096
+ case 'no-entry': {
2097
+ enum11 = 20;
2098
+ break;
2099
+ }
2100
+ case 'no-lock': {
2101
+ enum11 = 21;
2102
+ break;
2103
+ }
2104
+ case 'insufficient-memory': {
2105
+ enum11 = 22;
2106
+ break;
2107
+ }
2108
+ case 'insufficient-space': {
2109
+ enum11 = 23;
2110
+ break;
2111
+ }
2112
+ case 'not-directory': {
2113
+ enum11 = 24;
2114
+ break;
2115
+ }
2116
+ case 'not-empty': {
2117
+ enum11 = 25;
2118
+ break;
2119
+ }
2120
+ case 'not-recoverable': {
2121
+ enum11 = 26;
2122
+ break;
2123
+ }
2124
+ case 'unsupported': {
2125
+ enum11 = 27;
2126
+ break;
2127
+ }
2128
+ case 'no-tty': {
2129
+ enum11 = 28;
2130
+ break;
2131
+ }
2132
+ case 'no-such-device': {
2133
+ enum11 = 29;
2134
+ break;
2135
+ }
2136
+ case 'overflow': {
2137
+ enum11 = 30;
2138
+ break;
2139
+ }
2140
+ case 'not-permitted': {
2141
+ enum11 = 31;
2142
+ break;
2143
+ }
2144
+ case 'pipe': {
2145
+ enum11 = 32;
2146
+ break;
2147
+ }
2148
+ case 'read-only': {
2149
+ enum11 = 33;
2150
+ break;
2151
+ }
2152
+ case 'invalid-seek': {
2153
+ enum11 = 34;
2154
+ break;
2155
+ }
2156
+ case 'text-file-busy': {
2157
+ enum11 = 35;
2158
+ break;
2159
+ }
2160
+ case 'cross-device': {
2161
+ enum11 = 36;
2162
+ break;
2163
+ }
2164
+ default: {
2165
+ if ((e) instanceof Error) {
2166
+ console.error(e);
2167
+ }
2168
+
2169
+ throw new TypeError(`"${val11}" is not one of the cases of error-code`);
2170
+ }
2171
+ }
2172
+ dataView(memory0).setInt8(arg1 + 8, enum11, true);
2173
+ break;
2174
+ }
2175
+ default: {
2176
+ throw new TypeError('invalid variant specified for result');
2177
+ }
2178
+ }
2179
+ }
2180
+
2181
+ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
2182
+ var handle1 = arg0;
2183
+ var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
2184
+ var rsc0 = captureTable5.get(rep2);
2185
+ if (!rsc0) {
2186
+ rsc0 = Object.create(Descriptor.prototype);
2187
+ Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
2188
+ Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
2189
+ }
2190
+ curResourceBorrows.push(rsc0);
2191
+ if ((arg1 & 4294967294) !== 0) {
2192
+ throw new TypeError('flags have extraneous bits set');
2193
+ }
2194
+ var flags3 = {
2195
+ symlinkFollow: Boolean(arg1 & 1),
2196
+ };
2197
+ var ptr4 = arg2;
2198
+ var len4 = arg3;
2199
+ var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
2200
+ let ret;
2201
+ try {
2202
+ ret = { tag: 'ok', val: rsc0.statAt(flags3, result4)};
2203
+ } catch (e) {
2204
+ ret = { tag: 'err', val: getErrorPayload(e) };
2205
+ }
2206
+ for (const rsc of curResourceBorrows) {
2207
+ rsc[symbolRscHandle] = null;
2208
+ }
2209
+ curResourceBorrows = [];
2210
+ var variant14 = ret;
2211
+ switch (variant14.tag) {
2212
+ case 'ok': {
2213
+ const e = variant14.val;
2214
+ dataView(memory0).setInt8(arg4 + 0, 0, true);
2215
+ var {type: v5_0, linkCount: v5_1, size: v5_2, dataAccessTimestamp: v5_3, dataModificationTimestamp: v5_4, statusChangeTimestamp: v5_5 } = e;
2216
+ var val6 = v5_0;
2217
+ let enum6;
2218
+ switch (val6) {
2219
+ case 'unknown': {
2220
+ enum6 = 0;
2221
+ break;
2222
+ }
2223
+ case 'block-device': {
2224
+ enum6 = 1;
2225
+ break;
2226
+ }
2227
+ case 'character-device': {
2228
+ enum6 = 2;
2229
+ break;
2230
+ }
2231
+ case 'directory': {
2232
+ enum6 = 3;
2233
+ break;
2234
+ }
2235
+ case 'fifo': {
2236
+ enum6 = 4;
2237
+ break;
2238
+ }
2239
+ case 'symbolic-link': {
2240
+ enum6 = 5;
2241
+ break;
2242
+ }
2243
+ case 'regular-file': {
2244
+ enum6 = 6;
2245
+ break;
2246
+ }
2247
+ case 'socket': {
2248
+ enum6 = 7;
2249
+ break;
2250
+ }
2251
+ default: {
2252
+ if ((v5_0) instanceof Error) {
2253
+ console.error(v5_0);
2254
+ }
2255
+
2256
+ throw new TypeError(`"${val6}" is not one of the cases of descriptor-type`);
2257
+ }
2258
+ }
2259
+ dataView(memory0).setInt8(arg4 + 8, enum6, true);
2260
+ dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
2261
+ dataView(memory0).setBigInt64(arg4 + 24, toUint64(v5_2), true);
2262
+ var variant8 = v5_3;
2263
+ if (variant8 === null || variant8=== undefined) {
2264
+ dataView(memory0).setInt8(arg4 + 32, 0, true);
2265
+ } else {
2266
+ const e = variant8;
2267
+ dataView(memory0).setInt8(arg4 + 32, 1, true);
2268
+ var {seconds: v7_0, nanoseconds: v7_1 } = e;
2269
+ dataView(memory0).setBigInt64(arg4 + 40, toUint64(v7_0), true);
2270
+ dataView(memory0).setInt32(arg4 + 48, toUint32(v7_1), true);
2271
+ }
2272
+ var variant10 = v5_4;
2273
+ if (variant10 === null || variant10=== undefined) {
2274
+ dataView(memory0).setInt8(arg4 + 56, 0, true);
2275
+ } else {
2276
+ const e = variant10;
2277
+ dataView(memory0).setInt8(arg4 + 56, 1, true);
2278
+ var {seconds: v9_0, nanoseconds: v9_1 } = e;
2279
+ dataView(memory0).setBigInt64(arg4 + 64, toUint64(v9_0), true);
2280
+ dataView(memory0).setInt32(arg4 + 72, toUint32(v9_1), true);
2281
+ }
2282
+ var variant12 = v5_5;
2283
+ if (variant12 === null || variant12=== undefined) {
2284
+ dataView(memory0).setInt8(arg4 + 80, 0, true);
2285
+ } else {
2286
+ const e = variant12;
2287
+ dataView(memory0).setInt8(arg4 + 80, 1, true);
2288
+ var {seconds: v11_0, nanoseconds: v11_1 } = e;
2289
+ dataView(memory0).setBigInt64(arg4 + 88, toUint64(v11_0), true);
2290
+ dataView(memory0).setInt32(arg4 + 96, toUint32(v11_1), true);
2291
+ }
2131
2292
  break;
2132
2293
  }
2133
2294
  case 'err': {
2134
- const e = variant5.val;
2135
- dataView(memory0).setInt8(arg1 + 0, 1, true);
2136
- var val4 = e;
2137
- let enum4;
2138
- switch (val4) {
2295
+ const e = variant14.val;
2296
+ dataView(memory0).setInt8(arg4 + 0, 1, true);
2297
+ var val13 = e;
2298
+ let enum13;
2299
+ switch (val13) {
2139
2300
  case 'access': {
2140
- enum4 = 0;
2301
+ enum13 = 0;
2141
2302
  break;
2142
2303
  }
2143
2304
  case 'would-block': {
2144
- enum4 = 1;
2305
+ enum13 = 1;
2145
2306
  break;
2146
2307
  }
2147
2308
  case 'already': {
2148
- enum4 = 2;
2309
+ enum13 = 2;
2149
2310
  break;
2150
2311
  }
2151
2312
  case 'bad-descriptor': {
2152
- enum4 = 3;
2313
+ enum13 = 3;
2153
2314
  break;
2154
2315
  }
2155
2316
  case 'busy': {
2156
- enum4 = 4;
2317
+ enum13 = 4;
2157
2318
  break;
2158
2319
  }
2159
2320
  case 'deadlock': {
2160
- enum4 = 5;
2321
+ enum13 = 5;
2161
2322
  break;
2162
2323
  }
2163
2324
  case 'quota': {
2164
- enum4 = 6;
2325
+ enum13 = 6;
2165
2326
  break;
2166
2327
  }
2167
2328
  case 'exist': {
2168
- enum4 = 7;
2329
+ enum13 = 7;
2169
2330
  break;
2170
2331
  }
2171
2332
  case 'file-too-large': {
2172
- enum4 = 8;
2333
+ enum13 = 8;
2173
2334
  break;
2174
2335
  }
2175
2336
  case 'illegal-byte-sequence': {
2176
- enum4 = 9;
2337
+ enum13 = 9;
2177
2338
  break;
2178
2339
  }
2179
2340
  case 'in-progress': {
2180
- enum4 = 10;
2341
+ enum13 = 10;
2181
2342
  break;
2182
2343
  }
2183
2344
  case 'interrupted': {
2184
- enum4 = 11;
2345
+ enum13 = 11;
2185
2346
  break;
2186
2347
  }
2187
2348
  case 'invalid': {
2188
- enum4 = 12;
2349
+ enum13 = 12;
2189
2350
  break;
2190
2351
  }
2191
2352
  case 'io': {
2192
- enum4 = 13;
2353
+ enum13 = 13;
2193
2354
  break;
2194
2355
  }
2195
2356
  case 'is-directory': {
2196
- enum4 = 14;
2357
+ enum13 = 14;
2197
2358
  break;
2198
2359
  }
2199
2360
  case 'loop': {
2200
- enum4 = 15;
2361
+ enum13 = 15;
2201
2362
  break;
2202
2363
  }
2203
2364
  case 'too-many-links': {
2204
- enum4 = 16;
2365
+ enum13 = 16;
2205
2366
  break;
2206
2367
  }
2207
2368
  case 'message-size': {
2208
- enum4 = 17;
2369
+ enum13 = 17;
2209
2370
  break;
2210
2371
  }
2211
2372
  case 'name-too-long': {
2212
- enum4 = 18;
2373
+ enum13 = 18;
2213
2374
  break;
2214
2375
  }
2215
2376
  case 'no-device': {
2216
- enum4 = 19;
2377
+ enum13 = 19;
2217
2378
  break;
2218
2379
  }
2219
2380
  case 'no-entry': {
2220
- enum4 = 20;
2381
+ enum13 = 20;
2221
2382
  break;
2222
2383
  }
2223
2384
  case 'no-lock': {
2224
- enum4 = 21;
2385
+ enum13 = 21;
2225
2386
  break;
2226
2387
  }
2227
2388
  case 'insufficient-memory': {
2228
- enum4 = 22;
2389
+ enum13 = 22;
2229
2390
  break;
2230
2391
  }
2231
2392
  case 'insufficient-space': {
2232
- enum4 = 23;
2393
+ enum13 = 23;
2233
2394
  break;
2234
2395
  }
2235
2396
  case 'not-directory': {
2236
- enum4 = 24;
2397
+ enum13 = 24;
2237
2398
  break;
2238
2399
  }
2239
2400
  case 'not-empty': {
2240
- enum4 = 25;
2401
+ enum13 = 25;
2241
2402
  break;
2242
2403
  }
2243
2404
  case 'not-recoverable': {
2244
- enum4 = 26;
2405
+ enum13 = 26;
2245
2406
  break;
2246
2407
  }
2247
2408
  case 'unsupported': {
2248
- enum4 = 27;
2409
+ enum13 = 27;
2249
2410
  break;
2250
2411
  }
2251
2412
  case 'no-tty': {
2252
- enum4 = 28;
2413
+ enum13 = 28;
2253
2414
  break;
2254
2415
  }
2255
2416
  case 'no-such-device': {
2256
- enum4 = 29;
2417
+ enum13 = 29;
2257
2418
  break;
2258
2419
  }
2259
2420
  case 'overflow': {
2260
- enum4 = 30;
2421
+ enum13 = 30;
2261
2422
  break;
2262
2423
  }
2263
2424
  case 'not-permitted': {
2264
- enum4 = 31;
2425
+ enum13 = 31;
2265
2426
  break;
2266
2427
  }
2267
2428
  case 'pipe': {
2268
- enum4 = 32;
2429
+ enum13 = 32;
2269
2430
  break;
2270
2431
  }
2271
2432
  case 'read-only': {
2272
- enum4 = 33;
2433
+ enum13 = 33;
2273
2434
  break;
2274
2435
  }
2275
2436
  case 'invalid-seek': {
2276
- enum4 = 34;
2437
+ enum13 = 34;
2277
2438
  break;
2278
2439
  }
2279
2440
  case 'text-file-busy': {
2280
- enum4 = 35;
2441
+ enum13 = 35;
2281
2442
  break;
2282
2443
  }
2283
2444
  case 'cross-device': {
2284
- enum4 = 36;
2445
+ enum13 = 36;
2285
2446
  break;
2286
2447
  }
2287
2448
  default: {
@@ -2289,10 +2450,10 @@ function trampoline20(arg0, arg1) {
2289
2450
  console.error(e);
2290
2451
  }
2291
2452
 
2292
- throw new TypeError(`"${val4}" is not one of the cases of error-code`);
2453
+ throw new TypeError(`"${val13}" is not one of the cases of error-code`);
2293
2454
  }
2294
2455
  }
2295
- dataView(memory0).setInt8(arg1 + 8, enum4, true);
2456
+ dataView(memory0).setInt8(arg4 + 8, enum13, true);
2296
2457
  break;
2297
2458
  }
2298
2459
  default: {
@@ -2301,7 +2462,7 @@ function trampoline20(arg0, arg1) {
2301
2462
  }
2302
2463
  }
2303
2464
 
2304
- function trampoline21(arg0, arg1, arg2, arg3, arg4) {
2465
+ function trampoline22(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
2305
2466
  var handle1 = arg0;
2306
2467
  var rep2 = handleTable5[(handle1 << 1) + 1] & ~T_FLAG;
2307
2468
  var rsc0 = captureTable5.get(rep2);
@@ -2320,9 +2481,29 @@ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
2320
2481
  var ptr4 = arg2;
2321
2482
  var len4 = arg3;
2322
2483
  var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
2484
+ if ((arg4 & 4294967280) !== 0) {
2485
+ throw new TypeError('flags have extraneous bits set');
2486
+ }
2487
+ var flags5 = {
2488
+ create: Boolean(arg4 & 1),
2489
+ directory: Boolean(arg4 & 2),
2490
+ exclusive: Boolean(arg4 & 4),
2491
+ truncate: Boolean(arg4 & 8),
2492
+ };
2493
+ if ((arg5 & 4294967232) !== 0) {
2494
+ throw new TypeError('flags have extraneous bits set');
2495
+ }
2496
+ var flags6 = {
2497
+ read: Boolean(arg5 & 1),
2498
+ write: Boolean(arg5 & 2),
2499
+ fileIntegritySync: Boolean(arg5 & 4),
2500
+ dataIntegritySync: Boolean(arg5 & 8),
2501
+ requestedWriteSync: Boolean(arg5 & 16),
2502
+ mutateDirectory: Boolean(arg5 & 32),
2503
+ };
2323
2504
  let ret;
2324
2505
  try {
2325
- ret = { tag: 'ok', val: rsc0.metadataHashAt(flags3, result4)};
2506
+ ret = { tag: 'ok', val: rsc0.openAt(flags3, result4, flags5, flags6)};
2326
2507
  } catch (e) {
2327
2508
  ret = { tag: 'err', val: getErrorPayload(e) };
2328
2509
  }
@@ -2330,168 +2511,175 @@ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
2330
2511
  rsc[symbolRscHandle] = null;
2331
2512
  }
2332
2513
  curResourceBorrows = [];
2333
- var variant7 = ret;
2334
- switch (variant7.tag) {
2514
+ var variant9 = ret;
2515
+ switch (variant9.tag) {
2335
2516
  case 'ok': {
2336
- const e = variant7.val;
2337
- dataView(memory0).setInt8(arg4 + 0, 0, true);
2338
- var {lower: v5_0, upper: v5_1 } = e;
2339
- dataView(memory0).setBigInt64(arg4 + 8, toUint64(v5_0), true);
2340
- dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
2517
+ const e = variant9.val;
2518
+ dataView(memory0).setInt8(arg6 + 0, 0, true);
2519
+ if (!(e instanceof Descriptor)) {
2520
+ throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
2521
+ }
2522
+ var handle7 = e[symbolRscHandle];
2523
+ if (!handle7) {
2524
+ const rep = e[symbolRscRep] || ++captureCnt5;
2525
+ captureTable5.set(rep, e);
2526
+ handle7 = rscTableCreateOwn(handleTable5, rep);
2527
+ }
2528
+ dataView(memory0).setInt32(arg6 + 4, handle7, true);
2341
2529
  break;
2342
2530
  }
2343
2531
  case 'err': {
2344
- const e = variant7.val;
2345
- dataView(memory0).setInt8(arg4 + 0, 1, true);
2346
- var val6 = e;
2347
- let enum6;
2348
- switch (val6) {
2532
+ const e = variant9.val;
2533
+ dataView(memory0).setInt8(arg6 + 0, 1, true);
2534
+ var val8 = e;
2535
+ let enum8;
2536
+ switch (val8) {
2349
2537
  case 'access': {
2350
- enum6 = 0;
2538
+ enum8 = 0;
2351
2539
  break;
2352
2540
  }
2353
2541
  case 'would-block': {
2354
- enum6 = 1;
2542
+ enum8 = 1;
2355
2543
  break;
2356
2544
  }
2357
2545
  case 'already': {
2358
- enum6 = 2;
2546
+ enum8 = 2;
2359
2547
  break;
2360
2548
  }
2361
2549
  case 'bad-descriptor': {
2362
- enum6 = 3;
2550
+ enum8 = 3;
2363
2551
  break;
2364
2552
  }
2365
2553
  case 'busy': {
2366
- enum6 = 4;
2554
+ enum8 = 4;
2367
2555
  break;
2368
2556
  }
2369
2557
  case 'deadlock': {
2370
- enum6 = 5;
2558
+ enum8 = 5;
2371
2559
  break;
2372
2560
  }
2373
2561
  case 'quota': {
2374
- enum6 = 6;
2562
+ enum8 = 6;
2375
2563
  break;
2376
2564
  }
2377
2565
  case 'exist': {
2378
- enum6 = 7;
2566
+ enum8 = 7;
2379
2567
  break;
2380
2568
  }
2381
2569
  case 'file-too-large': {
2382
- enum6 = 8;
2570
+ enum8 = 8;
2383
2571
  break;
2384
2572
  }
2385
2573
  case 'illegal-byte-sequence': {
2386
- enum6 = 9;
2574
+ enum8 = 9;
2387
2575
  break;
2388
2576
  }
2389
2577
  case 'in-progress': {
2390
- enum6 = 10;
2578
+ enum8 = 10;
2391
2579
  break;
2392
2580
  }
2393
2581
  case 'interrupted': {
2394
- enum6 = 11;
2582
+ enum8 = 11;
2395
2583
  break;
2396
2584
  }
2397
2585
  case 'invalid': {
2398
- enum6 = 12;
2586
+ enum8 = 12;
2399
2587
  break;
2400
2588
  }
2401
2589
  case 'io': {
2402
- enum6 = 13;
2590
+ enum8 = 13;
2403
2591
  break;
2404
2592
  }
2405
2593
  case 'is-directory': {
2406
- enum6 = 14;
2594
+ enum8 = 14;
2407
2595
  break;
2408
2596
  }
2409
2597
  case 'loop': {
2410
- enum6 = 15;
2598
+ enum8 = 15;
2411
2599
  break;
2412
2600
  }
2413
2601
  case 'too-many-links': {
2414
- enum6 = 16;
2602
+ enum8 = 16;
2415
2603
  break;
2416
2604
  }
2417
2605
  case 'message-size': {
2418
- enum6 = 17;
2606
+ enum8 = 17;
2419
2607
  break;
2420
2608
  }
2421
2609
  case 'name-too-long': {
2422
- enum6 = 18;
2610
+ enum8 = 18;
2423
2611
  break;
2424
2612
  }
2425
2613
  case 'no-device': {
2426
- enum6 = 19;
2614
+ enum8 = 19;
2427
2615
  break;
2428
2616
  }
2429
2617
  case 'no-entry': {
2430
- enum6 = 20;
2618
+ enum8 = 20;
2431
2619
  break;
2432
2620
  }
2433
2621
  case 'no-lock': {
2434
- enum6 = 21;
2622
+ enum8 = 21;
2435
2623
  break;
2436
2624
  }
2437
2625
  case 'insufficient-memory': {
2438
- enum6 = 22;
2626
+ enum8 = 22;
2439
2627
  break;
2440
2628
  }
2441
2629
  case 'insufficient-space': {
2442
- enum6 = 23;
2630
+ enum8 = 23;
2443
2631
  break;
2444
2632
  }
2445
2633
  case 'not-directory': {
2446
- enum6 = 24;
2634
+ enum8 = 24;
2447
2635
  break;
2448
2636
  }
2449
2637
  case 'not-empty': {
2450
- enum6 = 25;
2638
+ enum8 = 25;
2451
2639
  break;
2452
2640
  }
2453
2641
  case 'not-recoverable': {
2454
- enum6 = 26;
2642
+ enum8 = 26;
2455
2643
  break;
2456
2644
  }
2457
2645
  case 'unsupported': {
2458
- enum6 = 27;
2646
+ enum8 = 27;
2459
2647
  break;
2460
2648
  }
2461
2649
  case 'no-tty': {
2462
- enum6 = 28;
2650
+ enum8 = 28;
2463
2651
  break;
2464
2652
  }
2465
2653
  case 'no-such-device': {
2466
- enum6 = 29;
2654
+ enum8 = 29;
2467
2655
  break;
2468
2656
  }
2469
2657
  case 'overflow': {
2470
- enum6 = 30;
2658
+ enum8 = 30;
2471
2659
  break;
2472
2660
  }
2473
2661
  case 'not-permitted': {
2474
- enum6 = 31;
2662
+ enum8 = 31;
2475
2663
  break;
2476
2664
  }
2477
2665
  case 'pipe': {
2478
- enum6 = 32;
2666
+ enum8 = 32;
2479
2667
  break;
2480
2668
  }
2481
2669
  case 'read-only': {
2482
- enum6 = 33;
2670
+ enum8 = 33;
2483
2671
  break;
2484
2672
  }
2485
2673
  case 'invalid-seek': {
2486
- enum6 = 34;
2674
+ enum8 = 34;
2487
2675
  break;
2488
2676
  }
2489
2677
  case 'text-file-busy': {
2490
- enum6 = 35;
2678
+ enum8 = 35;
2491
2679
  break;
2492
2680
  }
2493
2681
  case 'cross-device': {
2494
- enum6 = 36;
2682
+ enum8 = 36;
2495
2683
  break;
2496
2684
  }
2497
2685
  default: {
@@ -2499,10 +2687,10 @@ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
2499
2687
  console.error(e);
2500
2688
  }
2501
2689
 
2502
- throw new TypeError(`"${val6}" is not one of the cases of error-code`);
2690
+ throw new TypeError(`"${val8}" is not one of the cases of error-code`);
2503
2691
  }
2504
2692
  }
2505
- dataView(memory0).setInt8(arg4 + 8, enum6, true);
2693
+ dataView(memory0).setInt8(arg6 + 4, enum8, true);
2506
2694
  break;
2507
2695
  }
2508
2696
  default: {
@@ -2511,7 +2699,7 @@ function trampoline21(arg0, arg1, arg2, arg3, arg4) {
2511
2699
  }
2512
2700
  }
2513
2701
 
2514
- function trampoline22(arg0, arg1) {
2702
+ function trampoline23(arg0, arg1) {
2515
2703
  var handle1 = arg0;
2516
2704
  var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
2517
2705
  var rsc0 = captureTable6.get(rep2);
@@ -2688,268 +2876,80 @@ function trampoline22(arg0, arg1) {
2688
2876
  enum7 = 21;
2689
2877
  break;
2690
2878
  }
2691
- case 'insufficient-memory': {
2692
- enum7 = 22;
2693
- break;
2694
- }
2695
- case 'insufficient-space': {
2696
- enum7 = 23;
2697
- break;
2698
- }
2699
- case 'not-directory': {
2700
- enum7 = 24;
2701
- break;
2702
- }
2703
- case 'not-empty': {
2704
- enum7 = 25;
2705
- break;
2706
- }
2707
- case 'not-recoverable': {
2708
- enum7 = 26;
2709
- break;
2710
- }
2711
- case 'unsupported': {
2712
- enum7 = 27;
2713
- break;
2714
- }
2715
- case 'no-tty': {
2716
- enum7 = 28;
2717
- break;
2718
- }
2719
- case 'no-such-device': {
2720
- enum7 = 29;
2721
- break;
2722
- }
2723
- case 'overflow': {
2724
- enum7 = 30;
2725
- break;
2726
- }
2727
- case 'not-permitted': {
2728
- enum7 = 31;
2729
- break;
2730
- }
2731
- case 'pipe': {
2732
- enum7 = 32;
2733
- break;
2734
- }
2735
- case 'read-only': {
2736
- enum7 = 33;
2737
- break;
2738
- }
2739
- case 'invalid-seek': {
2740
- enum7 = 34;
2741
- break;
2742
- }
2743
- case 'text-file-busy': {
2744
- enum7 = 35;
2745
- break;
2746
- }
2747
- case 'cross-device': {
2748
- enum7 = 36;
2749
- break;
2750
- }
2751
- default: {
2752
- if ((e) instanceof Error) {
2753
- console.error(e);
2754
- }
2755
-
2756
- throw new TypeError(`"${val7}" is not one of the cases of error-code`);
2757
- }
2758
- }
2759
- dataView(memory0).setInt8(arg1 + 4, enum7, true);
2760
- break;
2761
- }
2762
- default: {
2763
- throw new TypeError('invalid variant specified for result');
2764
- }
2765
- }
2766
- }
2767
- const handleTable0 = [T_FLAG, 0];
2768
- const captureTable0= new Map();
2769
- let captureCnt0 = 0;
2770
- handleTables[0] = handleTable0;
2771
-
2772
- function trampoline23(arg0, arg1) {
2773
- var handle1 = arg0;
2774
- var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
2775
- var rsc0 = captureTable0.get(rep2);
2776
- if (!rsc0) {
2777
- rsc0 = Object.create(Error$1.prototype);
2778
- Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
2779
- Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
2780
- }
2781
- curResourceBorrows.push(rsc0);
2782
- const ret = filesystemErrorCode(rsc0);
2783
- for (const rsc of curResourceBorrows) {
2784
- rsc[symbolRscHandle] = null;
2785
- }
2786
- curResourceBorrows = [];
2787
- var variant4 = ret;
2788
- if (variant4 === null || variant4=== undefined) {
2789
- dataView(memory0).setInt8(arg1 + 0, 0, true);
2790
- } else {
2791
- const e = variant4;
2792
- dataView(memory0).setInt8(arg1 + 0, 1, true);
2793
- var val3 = e;
2794
- let enum3;
2795
- switch (val3) {
2796
- case 'access': {
2797
- enum3 = 0;
2798
- break;
2799
- }
2800
- case 'would-block': {
2801
- enum3 = 1;
2802
- break;
2803
- }
2804
- case 'already': {
2805
- enum3 = 2;
2806
- break;
2807
- }
2808
- case 'bad-descriptor': {
2809
- enum3 = 3;
2810
- break;
2811
- }
2812
- case 'busy': {
2813
- enum3 = 4;
2814
- break;
2815
- }
2816
- case 'deadlock': {
2817
- enum3 = 5;
2818
- break;
2819
- }
2820
- case 'quota': {
2821
- enum3 = 6;
2822
- break;
2823
- }
2824
- case 'exist': {
2825
- enum3 = 7;
2826
- break;
2827
- }
2828
- case 'file-too-large': {
2829
- enum3 = 8;
2830
- break;
2831
- }
2832
- case 'illegal-byte-sequence': {
2833
- enum3 = 9;
2834
- break;
2835
- }
2836
- case 'in-progress': {
2837
- enum3 = 10;
2838
- break;
2839
- }
2840
- case 'interrupted': {
2841
- enum3 = 11;
2842
- break;
2843
- }
2844
- case 'invalid': {
2845
- enum3 = 12;
2846
- break;
2847
- }
2848
- case 'io': {
2849
- enum3 = 13;
2850
- break;
2851
- }
2852
- case 'is-directory': {
2853
- enum3 = 14;
2854
- break;
2855
- }
2856
- case 'loop': {
2857
- enum3 = 15;
2858
- break;
2859
- }
2860
- case 'too-many-links': {
2861
- enum3 = 16;
2862
- break;
2863
- }
2864
- case 'message-size': {
2865
- enum3 = 17;
2866
- break;
2867
- }
2868
- case 'name-too-long': {
2869
- enum3 = 18;
2870
- break;
2871
- }
2872
- case 'no-device': {
2873
- enum3 = 19;
2874
- break;
2875
- }
2876
- case 'no-entry': {
2877
- enum3 = 20;
2878
- break;
2879
- }
2880
- case 'no-lock': {
2881
- enum3 = 21;
2882
- break;
2883
- }
2884
- case 'insufficient-memory': {
2885
- enum3 = 22;
2886
- break;
2887
- }
2888
- case 'insufficient-space': {
2889
- enum3 = 23;
2890
- break;
2891
- }
2892
- case 'not-directory': {
2893
- enum3 = 24;
2894
- break;
2895
- }
2896
- case 'not-empty': {
2897
- enum3 = 25;
2898
- break;
2899
- }
2900
- case 'not-recoverable': {
2901
- enum3 = 26;
2902
- break;
2903
- }
2904
- case 'unsupported': {
2905
- enum3 = 27;
2906
- break;
2907
- }
2908
- case 'no-tty': {
2909
- enum3 = 28;
2910
- break;
2911
- }
2912
- case 'no-such-device': {
2913
- enum3 = 29;
2914
- break;
2915
- }
2916
- case 'overflow': {
2917
- enum3 = 30;
2918
- break;
2919
- }
2920
- case 'not-permitted': {
2921
- enum3 = 31;
2922
- break;
2923
- }
2924
- case 'pipe': {
2925
- enum3 = 32;
2926
- break;
2927
- }
2928
- case 'read-only': {
2929
- enum3 = 33;
2930
- break;
2931
- }
2932
- case 'invalid-seek': {
2933
- enum3 = 34;
2934
- break;
2935
- }
2936
- case 'text-file-busy': {
2937
- enum3 = 35;
2938
- break;
2939
- }
2940
- case 'cross-device': {
2941
- enum3 = 36;
2942
- break;
2943
- }
2944
- default: {
2945
- if ((e) instanceof Error) {
2946
- console.error(e);
2879
+ case 'insufficient-memory': {
2880
+ enum7 = 22;
2881
+ break;
2882
+ }
2883
+ case 'insufficient-space': {
2884
+ enum7 = 23;
2885
+ break;
2886
+ }
2887
+ case 'not-directory': {
2888
+ enum7 = 24;
2889
+ break;
2890
+ }
2891
+ case 'not-empty': {
2892
+ enum7 = 25;
2893
+ break;
2894
+ }
2895
+ case 'not-recoverable': {
2896
+ enum7 = 26;
2897
+ break;
2898
+ }
2899
+ case 'unsupported': {
2900
+ enum7 = 27;
2901
+ break;
2902
+ }
2903
+ case 'no-tty': {
2904
+ enum7 = 28;
2905
+ break;
2906
+ }
2907
+ case 'no-such-device': {
2908
+ enum7 = 29;
2909
+ break;
2910
+ }
2911
+ case 'overflow': {
2912
+ enum7 = 30;
2913
+ break;
2914
+ }
2915
+ case 'not-permitted': {
2916
+ enum7 = 31;
2917
+ break;
2918
+ }
2919
+ case 'pipe': {
2920
+ enum7 = 32;
2921
+ break;
2922
+ }
2923
+ case 'read-only': {
2924
+ enum7 = 33;
2925
+ break;
2926
+ }
2927
+ case 'invalid-seek': {
2928
+ enum7 = 34;
2929
+ break;
2930
+ }
2931
+ case 'text-file-busy': {
2932
+ enum7 = 35;
2933
+ break;
2934
+ }
2935
+ case 'cross-device': {
2936
+ enum7 = 36;
2937
+ break;
2938
+ }
2939
+ default: {
2940
+ if ((e) instanceof Error) {
2941
+ console.error(e);
2942
+ }
2943
+
2944
+ throw new TypeError(`"${val7}" is not one of the cases of error-code`);
2947
2945
  }
2948
-
2949
- throw new TypeError(`"${val3}" is not one of the cases of error-code`);
2950
2946
  }
2947
+ dataView(memory0).setInt8(arg1 + 4, enum7, true);
2948
+ break;
2949
+ }
2950
+ default: {
2951
+ throw new TypeError('invalid variant specified for result');
2951
2952
  }
2952
- dataView(memory0).setInt8(arg1 + 1, enum3, true);
2953
2953
  }
2954
2954
  }
2955
2955
 
@@ -3464,97 +3464,6 @@ let exports3;
3464
3464
  let realloc1;
3465
3465
  let postReturn0;
3466
3466
  let postReturn1;
3467
- function trampoline0(handle) {
3468
- const handleEntry = rscTableRemove(handleTable6, handle);
3469
- if (handleEntry.own) {
3470
-
3471
- const rsc = captureTable6.get(handleEntry.rep);
3472
- if (rsc) {
3473
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3474
- captureTable6.delete(handleEntry.rep);
3475
- } else if (DirectoryEntryStream[symbolCabiDispose]) {
3476
- DirectoryEntryStream[symbolCabiDispose](handleEntry.rep);
3477
- }
3478
- }
3479
- }
3480
- function trampoline1(handle) {
3481
- const handleEntry = rscTableRemove(handleTable2, handle);
3482
- if (handleEntry.own) {
3483
-
3484
- const rsc = captureTable2.get(handleEntry.rep);
3485
- if (rsc) {
3486
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3487
- captureTable2.delete(handleEntry.rep);
3488
- } else if (OutputStream[symbolCabiDispose]) {
3489
- OutputStream[symbolCabiDispose](handleEntry.rep);
3490
- }
3491
- }
3492
- }
3493
- function trampoline2(handle) {
3494
- const handleEntry = rscTableRemove(handleTable0, handle);
3495
- if (handleEntry.own) {
3496
-
3497
- const rsc = captureTable0.get(handleEntry.rep);
3498
- if (rsc) {
3499
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3500
- captureTable0.delete(handleEntry.rep);
3501
- } else if (Error$1[symbolCabiDispose]) {
3502
- Error$1[symbolCabiDispose](handleEntry.rep);
3503
- }
3504
- }
3505
- }
3506
- function trampoline3(handle) {
3507
- const handleEntry = rscTableRemove(handleTable1, handle);
3508
- if (handleEntry.own) {
3509
-
3510
- const rsc = captureTable1.get(handleEntry.rep);
3511
- if (rsc) {
3512
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3513
- captureTable1.delete(handleEntry.rep);
3514
- } else if (InputStream[symbolCabiDispose]) {
3515
- InputStream[symbolCabiDispose](handleEntry.rep);
3516
- }
3517
- }
3518
- }
3519
- function trampoline4(handle) {
3520
- const handleEntry = rscTableRemove(handleTable5, handle);
3521
- if (handleEntry.own) {
3522
-
3523
- const rsc = captureTable5.get(handleEntry.rep);
3524
- if (rsc) {
3525
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3526
- captureTable5.delete(handleEntry.rep);
3527
- } else if (Descriptor[symbolCabiDispose]) {
3528
- Descriptor[symbolCabiDispose](handleEntry.rep);
3529
- }
3530
- }
3531
- }
3532
- function trampoline6(handle) {
3533
- const handleEntry = rscTableRemove(handleTable3, handle);
3534
- if (handleEntry.own) {
3535
-
3536
- const rsc = captureTable3.get(handleEntry.rep);
3537
- if (rsc) {
3538
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3539
- captureTable3.delete(handleEntry.rep);
3540
- } else if (TerminalInput[symbolCabiDispose]) {
3541
- TerminalInput[symbolCabiDispose](handleEntry.rep);
3542
- }
3543
- }
3544
- }
3545
- function trampoline7(handle) {
3546
- const handleEntry = rscTableRemove(handleTable4, handle);
3547
- if (handleEntry.own) {
3548
-
3549
- const rsc = captureTable4.get(handleEntry.rep);
3550
- if (rsc) {
3551
- if (rsc[symbolDispose]) rsc[symbolDispose]();
3552
- captureTable4.delete(handleEntry.rep);
3553
- } else if (TerminalOutput[symbolCabiDispose]) {
3554
- TerminalOutput[symbolCabiDispose](handleEntry.rep);
3555
- }
3556
- }
3557
- }
3558
3467
 
3559
3468
  function parse(arg0) {
3560
3469
  if (!_initialized) throwUninitialized();
@@ -4128,30 +4037,121 @@ function metadataAdd(arg0, arg1) {
4128
4037
  }
4129
4038
  return retVal.val;
4130
4039
  }
4040
+ function trampoline0(handle) {
4041
+ const handleEntry = rscTableRemove(handleTable6, handle);
4042
+ if (handleEntry.own) {
4043
+
4044
+ const rsc = captureTable6.get(handleEntry.rep);
4045
+ if (rsc) {
4046
+ if (rsc[symbolDispose]) rsc[symbolDispose]();
4047
+ captureTable6.delete(handleEntry.rep);
4048
+ } else if (DirectoryEntryStream[symbolCabiDispose]) {
4049
+ DirectoryEntryStream[symbolCabiDispose](handleEntry.rep);
4050
+ }
4051
+ }
4052
+ }
4053
+ function trampoline1(handle) {
4054
+ const handleEntry = rscTableRemove(handleTable2, handle);
4055
+ if (handleEntry.own) {
4056
+
4057
+ const rsc = captureTable2.get(handleEntry.rep);
4058
+ if (rsc) {
4059
+ if (rsc[symbolDispose]) rsc[symbolDispose]();
4060
+ captureTable2.delete(handleEntry.rep);
4061
+ } else if (OutputStream[symbolCabiDispose]) {
4062
+ OutputStream[symbolCabiDispose](handleEntry.rep);
4063
+ }
4064
+ }
4065
+ }
4066
+ function trampoline2(handle) {
4067
+ const handleEntry = rscTableRemove(handleTable0, handle);
4068
+ if (handleEntry.own) {
4069
+
4070
+ const rsc = captureTable0.get(handleEntry.rep);
4071
+ if (rsc) {
4072
+ if (rsc[symbolDispose]) rsc[symbolDispose]();
4073
+ captureTable0.delete(handleEntry.rep);
4074
+ } else if (Error$1[symbolCabiDispose]) {
4075
+ Error$1[symbolCabiDispose](handleEntry.rep);
4076
+ }
4077
+ }
4078
+ }
4079
+ function trampoline3(handle) {
4080
+ const handleEntry = rscTableRemove(handleTable1, handle);
4081
+ if (handleEntry.own) {
4082
+
4083
+ const rsc = captureTable1.get(handleEntry.rep);
4084
+ if (rsc) {
4085
+ if (rsc[symbolDispose]) rsc[symbolDispose]();
4086
+ captureTable1.delete(handleEntry.rep);
4087
+ } else if (InputStream[symbolCabiDispose]) {
4088
+ InputStream[symbolCabiDispose](handleEntry.rep);
4089
+ }
4090
+ }
4091
+ }
4092
+ function trampoline4(handle) {
4093
+ const handleEntry = rscTableRemove(handleTable5, handle);
4094
+ if (handleEntry.own) {
4095
+
4096
+ const rsc = captureTable5.get(handleEntry.rep);
4097
+ if (rsc) {
4098
+ if (rsc[symbolDispose]) rsc[symbolDispose]();
4099
+ captureTable5.delete(handleEntry.rep);
4100
+ } else if (Descriptor[symbolCabiDispose]) {
4101
+ Descriptor[symbolCabiDispose](handleEntry.rep);
4102
+ }
4103
+ }
4104
+ }
4105
+ function trampoline6(handle) {
4106
+ const handleEntry = rscTableRemove(handleTable3, handle);
4107
+ if (handleEntry.own) {
4108
+
4109
+ const rsc = captureTable3.get(handleEntry.rep);
4110
+ if (rsc) {
4111
+ if (rsc[symbolDispose]) rsc[symbolDispose]();
4112
+ captureTable3.delete(handleEntry.rep);
4113
+ } else if (TerminalInput[symbolCabiDispose]) {
4114
+ TerminalInput[symbolCabiDispose](handleEntry.rep);
4115
+ }
4116
+ }
4117
+ }
4118
+ function trampoline7(handle) {
4119
+ const handleEntry = rscTableRemove(handleTable4, handle);
4120
+ if (handleEntry.own) {
4121
+
4122
+ const rsc = captureTable4.get(handleEntry.rep);
4123
+ if (rsc) {
4124
+ if (rsc[symbolDispose]) rsc[symbolDispose]();
4125
+ captureTable4.delete(handleEntry.rep);
4126
+ } else if (TerminalOutput[symbolCabiDispose]) {
4127
+ TerminalOutput[symbolCabiDispose](handleEntry.rep);
4128
+ }
4129
+ }
4130
+ }
4131
4131
 
4132
4132
  let _initialized = false;
4133
4133
  export const $init = (() => {
4134
4134
  let gen = (function* init () {
4135
4135
  const module0 = fetchCompile(new URL('./wasm-tools.core.wasm', import.meta.url));
4136
4136
  const module1 = fetchCompile(new URL('./wasm-tools.core2.wasm', import.meta.url));
4137
- const module2 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBX9/f39/AGAEf39/fwBgBH9/f38Bf2AHf39/f39/fwBgAn5/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX8DJiUBAwMAAAAABAcABAAAAwMABQUACAEBAQEGCQoLAgYCAgIMAg0BBAUBcAElJQe7ASYBMAAAATEAAQEyAAIBMwADATQABAE1AAUBNgAGATcABwE4AAgBOQAJAjEwAAoCMTEACwIxMgAMAjEzAA0CMTQADgIxNQAPAjE2ABACMTcAEQIxOAASAjE5ABMCMjAAFAIyMQAVAjIyABYCMjMAFwIyNAAYAjI1ABkCMjYAGgIyNwAbAjI4ABwCMjkAHQIzMAAeAjMxAB8CMzIAIAIzMwAhAjM0ACICMzUAIwIzNgAkCCRpbXBvcnRzAQAK+QMlCQAgAEEAEQEACw0AIAAgASACQQERAwALDQAgACABIAJBAhEDAAsLACAAIAFBAxEAAAsLACAAIAFBBBEAAAsLACAAIAFBBREAAAsLACAAIAFBBhEAAAsRACAAIAEgAiADIARBBxEEAAsVACAAIAEgAiADIAQgBSAGQQgRBwALCwAgACABQQkRAAALEQAgACABIAIgAyAEQQoRBAALCwAgACABQQsRAAALCwAgACABQQwRAAALDQAgACABIAJBDREDAAsNACAAIAEgAkEOEQMACwsAIAAgAUEPEQAACw8AIAAgASACIANBEBEFAAsPACAAIAEgAiADQRERBQALCwAgACABQRIRAAALCwAgACABQRMRCAALCQAgAEEUEQEACwkAIABBFREBAAsJACAAQRYRAQALCQAgAEEXEQEACw8AIAAgASACIANBGBEGAAsZACAAIAEgAiADIAQgBSAGIAcgCEEZEQkACxEAIAAgASACIAMgBEEaEQoACxEAIAAgASACIAMgBEEbEQsACwsAIAAgAUEcEQIACw8AIAAgASACIANBHREGAAsLACAAIAFBHhECAAsLACAAIAFBHxECAAsLACAAIAFBIBECAAsJACAAQSERDAALCwAgACABQSIRAgALDQAgACABIAJBIxENAAsJACAAQSQRAQALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yMTcuMA');
4138
- const module3 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBX9/f39/AGAEf39/fwBgBH9/f38Bf2AHf39/f39/fwBgAn5/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX8C5AEmAAEwAAEAATEAAwABMgADAAEzAAAAATQAAAABNQAAAAE2AAAAATcABAABOAAHAAE5AAAAAjEwAAQAAjExAAAAAjEyAAAAAjEzAAMAAjE0AAMAAjE1AAAAAjE2AAUAAjE3AAUAAjE4AAAAAjE5AAgAAjIwAAEAAjIxAAEAAjIyAAEAAjIzAAEAAjI0AAYAAjI1AAkAAjI2AAoAAjI3AAsAAjI4AAIAAjI5AAYAAjMwAAIAAjMxAAIAAjMyAAIAAjMzAAwAAjM0AAIAAjM1AA0AAjM2AAEACCRpbXBvcnRzAXABJSUJKwEAQQALJQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQALwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAcwLjIxNy4w');
4137
+ const module2 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwADJiUEBwgJAgIEAgIKAgsBAQAAAAAABQMDAAUMAAMDAAYGAA0BAQEBBAUBcAElJQe7ASYBMAAAATEAAQEyAAIBMwADATQABAE1AAUBNgAGATcABwE4AAgBOQAJAjEwAAoCMTEACwIxMgAMAjEzAA0CMTQADgIxNQAPAjE2ABACMTcAEQIxOAASAjE5ABMCMjAAFAIyMQAVAjIyABYCMjMAFwIyNAAYAjI1ABkCMjYAGgIyNwAbAjI4ABwCMjkAHQIzMAAeAjMxAB8CMzIAIAIzMwAhAjM0ACICMzUAIwIzNgAkCCRpbXBvcnRzAQAK+QMlDwAgACABIAIgA0EAEQQACxkAIAAgASACIAMgBCAFIAYgByAIQQERBwALEQAgACABIAIgAyAEQQIRCAALEQAgACABIAIgAyAEQQMRCQALCwAgACABQQQRAgALCwAgACABQQURAgALDwAgACABIAIgA0EGEQQACwsAIAAgAUEHEQIACwsAIAAgAUEIEQIACwkAIABBCREKAAsLACAAIAFBChECAAsNACAAIAEgAkELEQsACwkAIABBDBEBAAsJACAAQQ0RAQALCwAgACABQQ4RAAALCwAgACABQQ8RAAALCwAgACABQRARAAALCwAgACABQRERAAALCwAgACABQRIRAAALEQAgACABIAIgAyAEQRMRBQALDQAgACABIAJBFBEDAAsNACAAIAEgAkEVEQMACwsAIAAgAUEWEQAACxEAIAAgASACIAMgBEEXEQUACxUAIAAgASACIAMgBCAFIAZBGBEMAAsLACAAIAFBGREAAAsNACAAIAEgAkEaEQMACw0AIAAgASACQRsRAwALCwAgACABQRwRAAALDwAgACABIAIgA0EdEQYACw8AIAAgASACIANBHhEGAAsLACAAIAFBHxEAAAsLACAAIAFBIBENAAsJACAAQSERAQALCQAgAEEiEQEACwkAIABBIxEBAAsJACAAQSQRAQALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yMTguMA');
4138
+ const module3 = base64Compile('AGFzbQEAAAABZw5gAn9/AGABfwBgAn9/AX9gA39+fwBgBH9/f38Bf2AFf39/f38AYAR/f39/AGAJf39/f39+fn9/AX9gBX9/f35/AX9gBX9/f39/AX9gAX8Bf2ADf39/AX9gB39/f39/f38AYAJ+fwAC5AEmAAEwAAQAATEABwABMgAIAAEzAAkAATQAAgABNQACAAE2AAQAATcAAgABOAACAAE5AAoAAjEwAAIAAjExAAsAAjEyAAEAAjEzAAEAAjE0AAAAAjE1AAAAAjE2AAAAAjE3AAAAAjE4AAAAAjE5AAUAAjIwAAMAAjIxAAMAAjIyAAAAAjIzAAUAAjI0AAwAAjI1AAAAAjI2AAMAAjI3AAMAAjI4AAAAAjI5AAYAAjMwAAYAAjMxAAAAAjMyAA0AAjMzAAEAAjM0AAEAAjM1AAEAAjM2AAEACCRpbXBvcnRzAXABJSUJKwEAQQALJQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQALwlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAcwLjIxOC4w');
4139
4139
  ({ exports: exports0 } = yield instantiateCore(yield module2));
4140
4140
  ({ exports: exports1 } = yield instantiateCore(yield module0, {
4141
4141
  wasi_snapshot_preview1: {
4142
- environ_get: exports0['31'],
4143
- environ_sizes_get: exports0['32'],
4144
- fd_close: exports0['33'],
4145
- fd_filestat_get: exports0['28'],
4146
- fd_prestat_dir_name: exports0['35'],
4147
- fd_prestat_get: exports0['34'],
4148
- fd_read: exports0['29'],
4149
- fd_readdir: exports0['26'],
4150
- fd_write: exports0['24'],
4151
- path_filestat_get: exports0['27'],
4152
- path_open: exports0['25'],
4153
- proc_exit: exports0['36'],
4154
- random_get: exports0['30'],
4142
+ environ_get: exports0['7'],
4143
+ environ_sizes_get: exports0['8'],
4144
+ fd_close: exports0['9'],
4145
+ fd_filestat_get: exports0['5'],
4146
+ fd_prestat_dir_name: exports0['11'],
4147
+ fd_prestat_get: exports0['10'],
4148
+ fd_read: exports0['6'],
4149
+ fd_readdir: exports0['2'],
4150
+ fd_write: exports0['0'],
4151
+ path_filestat_get: exports0['3'],
4152
+ path_open: exports0['1'],
4153
+ proc_exit: exports0['12'],
4154
+ random_get: exports0['4'],
4155
4155
  },
4156
4156
  }));
4157
4157
  ({ exports: exports2 } = yield instantiateCore(yield module1, {
@@ -4161,70 +4161,70 @@ export const $init = (() => {
4161
4161
  env: {
4162
4162
  memory: exports1.memory,
4163
4163
  },
4164
- 'wasi:cli/environment@0.2.1': {
4165
- 'get-environment': exports0['0'],
4164
+ 'wasi:cli/environment@0.2.2': {
4165
+ 'get-environment': exports0['13'],
4166
4166
  },
4167
- 'wasi:cli/exit@0.2.1': {
4167
+ 'wasi:cli/exit@0.2.2': {
4168
4168
  exit: trampoline10,
4169
4169
  },
4170
- 'wasi:cli/stderr@0.2.1': {
4170
+ 'wasi:cli/stderr@0.2.2': {
4171
4171
  'get-stderr': trampoline5,
4172
4172
  },
4173
- 'wasi:cli/stdin@0.2.1': {
4173
+ 'wasi:cli/stdin@0.2.2': {
4174
4174
  'get-stdin': trampoline8,
4175
4175
  },
4176
- 'wasi:cli/stdout@0.2.1': {
4176
+ 'wasi:cli/stdout@0.2.2': {
4177
4177
  'get-stdout': trampoline9,
4178
4178
  },
4179
- 'wasi:cli/terminal-input@0.2.1': {
4179
+ 'wasi:cli/terminal-input@0.2.2': {
4180
4180
  '[resource-drop]terminal-input': trampoline6,
4181
4181
  },
4182
- 'wasi:cli/terminal-output@0.2.1': {
4182
+ 'wasi:cli/terminal-output@0.2.2': {
4183
4183
  '[resource-drop]terminal-output': trampoline7,
4184
4184
  },
4185
- 'wasi:cli/terminal-stderr@0.2.1': {
4186
- 'get-terminal-stderr': exports0['23'],
4185
+ 'wasi:cli/terminal-stderr@0.2.2': {
4186
+ 'get-terminal-stderr': exports0['36'],
4187
4187
  },
4188
- 'wasi:cli/terminal-stdin@0.2.1': {
4189
- 'get-terminal-stdin': exports0['21'],
4188
+ 'wasi:cli/terminal-stdin@0.2.2': {
4189
+ 'get-terminal-stdin': exports0['34'],
4190
4190
  },
4191
- 'wasi:cli/terminal-stdout@0.2.1': {
4192
- 'get-terminal-stdout': exports0['22'],
4191
+ 'wasi:cli/terminal-stdout@0.2.2': {
4192
+ 'get-terminal-stdout': exports0['35'],
4193
4193
  },
4194
- 'wasi:filesystem/preopens@0.2.1': {
4195
- 'get-directories': exports0['20'],
4194
+ 'wasi:filesystem/preopens@0.2.2': {
4195
+ 'get-directories': exports0['33'],
4196
4196
  },
4197
- 'wasi:filesystem/types@0.2.1': {
4198
- '[method]descriptor.append-via-stream': exports0['3'],
4199
- '[method]descriptor.get-type': exports0['4'],
4200
- '[method]descriptor.metadata-hash': exports0['9'],
4201
- '[method]descriptor.metadata-hash-at': exports0['10'],
4202
- '[method]descriptor.open-at': exports0['8'],
4203
- '[method]descriptor.read-directory': exports0['5'],
4204
- '[method]descriptor.read-via-stream': exports0['1'],
4205
- '[method]descriptor.stat': exports0['6'],
4206
- '[method]descriptor.stat-at': exports0['7'],
4207
- '[method]descriptor.write-via-stream': exports0['2'],
4208
- '[method]directory-entry-stream.read-directory-entry': exports0['11'],
4197
+ 'wasi:filesystem/types@0.2.2': {
4198
+ '[method]descriptor.append-via-stream': exports0['16'],
4199
+ '[method]descriptor.get-type': exports0['14'],
4200
+ '[method]descriptor.metadata-hash': exports0['15'],
4201
+ '[method]descriptor.metadata-hash-at': exports0['19'],
4202
+ '[method]descriptor.open-at': exports0['24'],
4203
+ '[method]descriptor.read-directory': exports0['18'],
4204
+ '[method]descriptor.read-via-stream': exports0['20'],
4205
+ '[method]descriptor.stat': exports0['22'],
4206
+ '[method]descriptor.stat-at': exports0['23'],
4207
+ '[method]descriptor.write-via-stream': exports0['21'],
4208
+ '[method]directory-entry-stream.read-directory-entry': exports0['25'],
4209
4209
  '[resource-drop]descriptor': trampoline4,
4210
4210
  '[resource-drop]directory-entry-stream': trampoline0,
4211
- 'filesystem-error-code': exports0['12'],
4211
+ 'filesystem-error-code': exports0['17'],
4212
4212
  },
4213
- 'wasi:io/error@0.2.1': {
4213
+ 'wasi:io/error@0.2.2': {
4214
4214
  '[resource-drop]error': trampoline2,
4215
4215
  },
4216
- 'wasi:io/streams@0.2.1': {
4217
- '[method]input-stream.blocking-read': exports0['14'],
4218
- '[method]input-stream.read': exports0['13'],
4219
- '[method]output-stream.blocking-flush': exports0['18'],
4220
- '[method]output-stream.blocking-write-and-flush': exports0['17'],
4221
- '[method]output-stream.check-write': exports0['15'],
4222
- '[method]output-stream.write': exports0['16'],
4216
+ 'wasi:io/streams@0.2.2': {
4217
+ '[method]input-stream.blocking-read': exports0['27'],
4218
+ '[method]input-stream.read': exports0['26'],
4219
+ '[method]output-stream.blocking-flush': exports0['31'],
4220
+ '[method]output-stream.blocking-write-and-flush': exports0['30'],
4221
+ '[method]output-stream.check-write': exports0['28'],
4222
+ '[method]output-stream.write': exports0['29'],
4223
4223
  '[resource-drop]input-stream': trampoline3,
4224
4224
  '[resource-drop]output-stream': trampoline1,
4225
4225
  },
4226
- 'wasi:random/random@0.2.1': {
4227
- 'get-random-bytes': exports0['19'],
4226
+ 'wasi:random/random@0.2.2': {
4227
+ 'get-random-bytes': exports0['32'],
4228
4228
  },
4229
4229
  }));
4230
4230
  memory0 = exports1.memory;
@@ -4232,43 +4232,43 @@ export const $init = (() => {
4232
4232
  ({ exports: exports3 } = yield instantiateCore(yield module3, {
4233
4233
  '': {
4234
4234
  $imports: exports0.$imports,
4235
- '0': trampoline11,
4236
- '1': trampoline12,
4237
- '10': trampoline21,
4238
- '11': trampoline22,
4239
- '12': trampoline23,
4240
- '13': trampoline24,
4241
- '14': trampoline25,
4242
- '15': trampoline26,
4243
- '16': trampoline27,
4244
- '17': trampoline28,
4245
- '18': trampoline29,
4246
- '19': trampoline30,
4247
- '2': trampoline13,
4248
- '20': trampoline31,
4249
- '21': trampoline32,
4250
- '22': trampoline33,
4251
- '23': trampoline34,
4252
- '24': exports2.fd_write,
4253
- '25': exports2.path_open,
4254
- '26': exports2.fd_readdir,
4255
- '27': exports2.path_filestat_get,
4256
- '28': exports2.fd_filestat_get,
4257
- '29': exports2.fd_read,
4258
- '3': trampoline14,
4259
- '30': exports2.random_get,
4260
- '31': exports2.environ_get,
4261
- '32': exports2.environ_sizes_get,
4262
- '33': exports2.fd_close,
4263
- '34': exports2.fd_prestat_get,
4264
- '35': exports2.fd_prestat_dir_name,
4265
- '36': exports2.proc_exit,
4266
- '4': trampoline15,
4267
- '5': trampoline16,
4268
- '6': trampoline17,
4269
- '7': trampoline18,
4270
- '8': trampoline19,
4271
- '9': trampoline20,
4235
+ '0': exports2.fd_write,
4236
+ '1': exports2.path_open,
4237
+ '10': exports2.fd_prestat_get,
4238
+ '11': exports2.fd_prestat_dir_name,
4239
+ '12': exports2.proc_exit,
4240
+ '13': trampoline11,
4241
+ '14': trampoline12,
4242
+ '15': trampoline13,
4243
+ '16': trampoline14,
4244
+ '17': trampoline15,
4245
+ '18': trampoline16,
4246
+ '19': trampoline17,
4247
+ '2': exports2.fd_readdir,
4248
+ '20': trampoline18,
4249
+ '21': trampoline19,
4250
+ '22': trampoline20,
4251
+ '23': trampoline21,
4252
+ '24': trampoline22,
4253
+ '25': trampoline23,
4254
+ '26': trampoline24,
4255
+ '27': trampoline25,
4256
+ '28': trampoline26,
4257
+ '29': trampoline27,
4258
+ '3': exports2.path_filestat_get,
4259
+ '30': trampoline28,
4260
+ '31': trampoline29,
4261
+ '32': trampoline30,
4262
+ '33': trampoline31,
4263
+ '34': trampoline32,
4264
+ '35': trampoline33,
4265
+ '36': trampoline34,
4266
+ '4': exports2.random_get,
4267
+ '5': exports2.fd_filestat_get,
4268
+ '6': exports2.fd_read,
4269
+ '7': exports2.environ_get,
4270
+ '8': exports2.environ_sizes_get,
4271
+ '9': exports2.fd_close,
4272
4272
  },
4273
4273
  }));
4274
4274
  realloc1 = exports1.cabi_realloc;