@bytecodealliance/jco 0.13.1 → 0.13.3

package/obj/wasm-tools.js

@@ -53,7 +53,9 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 const instantiateCore = WebAssembly.instantiate;
 
-const resourceHandleSymbol = Symbol();
+const resourceHandleSymbol = Symbol('resource');
+
+const symbolDispose = Symbol.dispose || Symbol.for('dispose');
 
 function throwUninitialized() {
   throw new TypeError('Wasm uninitialized use `await $init` first');
@@ -179,178 +181,179 @@ let memory0;
 let realloc0;
 
 function trampoline13(arg0, arg1, arg2) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.readViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
       if (!(e instanceof InputStream)) {
         throw new Error('Not a valid "InputStream" resource.');
       }
-      const handle1 = handleCnt0++;
-      handleTable0.set(handle1, { rep: e, own: true });
-      dataView(memory0).setInt32(arg2 + 4, handle1, true);
+      const handle2 = handleCnt0++;
+      handleTable0.set(handle2, { rep: e, own: true });
+      dataView(memory0).setInt32(arg2 + 4, handle2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      const val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -358,10 +361,10 @@ function trampoline13(arg0, arg1, arg2) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg2 + 4, enum2, true);
+      dataView(memory0).setInt8(arg2 + 4, enum3, true);
       break;
     }
     default: {
@@ -371,178 +374,179 @@ function trampoline13(arg0, arg1, arg2) {
 }
 
 function trampoline14(arg0, arg1, arg2) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.writeViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
       if (!(e instanceof OutputStream)) {
         throw new Error('Not a valid "OutputStream" resource.');
       }
-      const handle1 = handleCnt2++;
-      handleTable2.set(handle1, { rep: e, own: true });
-      dataView(memory0).setInt32(arg2 + 4, handle1, true);
+      const handle2 = handleCnt2++;
+      handleTable2.set(handle2, { rep: e, own: true });
+      dataView(memory0).setInt32(arg2 + 4, handle2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      const val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -550,10 +554,10 @@ function trampoline14(arg0, arg1, arg2) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg2 + 4, enum2, true);
+      dataView(memory0).setInt8(arg2 + 4, enum3, true);
       break;
     }
     default: {
@@ -563,178 +567,179 @@ function trampoline14(arg0, arg1, arg2) {
 }
 
 function trampoline15(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.appendViaStream.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       if (!(e instanceof OutputStream)) {
         throw new Error('Not a valid "OutputStream" resource.');
       }
-      const handle1 = handleCnt2++;
-      handleTable2.set(handle1, { rep: e, own: true });
-      dataView(memory0).setInt32(arg1 + 4, handle1, true);
+      const handle2 = handleCnt2++;
+      handleTable2.set(handle2, { rep: e, own: true });
+      dataView(memory0).setInt32(arg1 + 4, handle2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      const val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -742,10 +747,10 @@ function trampoline15(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 4, enum2, true);
+      dataView(memory0).setInt8(arg1 + 4, enum3, true);
       break;
     }
     default: {
@@ -755,51 +760,52 @@ function trampoline15(arg0, arg1) {
 }
 
 function trampoline16(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.getType.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const val1 = e;
-      let enum1;
-      switch (val1) {
+      const val2 = e;
+      let enum2;
+      switch (val2) {
         case 'unknown': {
-          enum1 = 0;
+          enum2 = 0;
           break;
         }
         case 'block-device': {
-          enum1 = 1;
+          enum2 = 1;
           break;
         }
         case 'character-device': {
-          enum1 = 2;
+          enum2 = 2;
           break;
         }
         case 'directory': {
-          enum1 = 3;
+          enum2 = 3;
           break;
         }
         case 'fifo': {
-          enum1 = 4;
+          enum2 = 4;
           break;
         }
         case 'symbolic-link': {
-          enum1 = 5;
+          enum2 = 5;
           break;
         }
         case 'regular-file': {
-          enum1 = 6;
+          enum2 = 6;
           break;
         }
         case 'socket': {
-          enum1 = 7;
+          enum2 = 7;
           break;
         }
         default: {
@@ -807,164 +813,164 @@ function trampoline16(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val1}" is not one of the cases of descriptor-type`);
+          throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 1, enum1, true);
+      dataView(memory0).setInt8(arg1 + 1, enum2, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      const val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -972,10 +978,10 @@ function trampoline16(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 1, enum2, true);
+      dataView(memory0).setInt8(arg1 + 1, enum3, true);
       break;
     }
     default: {
@@ -985,249 +991,250 @@ function trampoline16(arg0, arg1) {
 }
 
 function trampoline17(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.stat.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant10 = ret;
-  switch (variant10.tag) {
+  const variant11 = ret;
+  switch (variant11.tag) {
     case 'ok': {
-      const e = variant10.val;
+      const e = variant11.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const {type: v1_0, linkCount: v1_1, size: v1_2, dataAccessTimestamp: v1_3, dataModificationTimestamp: v1_4, statusChangeTimestamp: v1_5 } = e;
-      const val2 = v1_0;
-      let enum2;
-      switch (val2) {
+      const {type: v2_0, linkCount: v2_1, size: v2_2, dataAccessTimestamp: v2_3, dataModificationTimestamp: v2_4, statusChangeTimestamp: v2_5 } = e;
+      const val3 = v2_0;
+      let enum3;
+      switch (val3) {
         case 'unknown': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'block-device': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'character-device': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'directory': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'fifo': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'symbolic-link': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'regular-file': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'socket': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         default: {
-          if ((v1_0) instanceof Error) {
-            console.error(v1_0);
+          if ((v2_0) instanceof Error) {
+            console.error(v2_0);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
+          throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum2, true);
-      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v1_1), true);
-      dataView(memory0).setBigInt64(arg1 + 24, toUint64(v1_2), true);
-      const variant4 = v1_3;
-      if (variant4 === null || variant4=== undefined) {
+      dataView(memory0).setInt8(arg1 + 8, enum3, true);
+      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
+      dataView(memory0).setBigInt64(arg1 + 24, toUint64(v2_2), true);
+      const variant5 = v2_3;
+      if (variant5 === null || variant5=== undefined) {
         dataView(memory0).setInt8(arg1 + 32, 0, true);
       } else {
-        const e = variant4;
+        const e = variant5;
         dataView(memory0).setInt8(arg1 + 32, 1, true);
-        const {seconds: v3_0, nanoseconds: v3_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 40, toUint64(v3_0), true);
-        dataView(memory0).setInt32(arg1 + 48, toUint32(v3_1), true);
+        const {seconds: v4_0, nanoseconds: v4_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 40, toUint64(v4_0), true);
+        dataView(memory0).setInt32(arg1 + 48, toUint32(v4_1), true);
       }
-      const variant6 = v1_4;
-      if (variant6 === null || variant6=== undefined) {
+      const variant7 = v2_4;
+      if (variant7 === null || variant7=== undefined) {
         dataView(memory0).setInt8(arg1 + 56, 0, true);
       } else {
-        const e = variant6;
+        const e = variant7;
         dataView(memory0).setInt8(arg1 + 56, 1, true);
-        const {seconds: v5_0, nanoseconds: v5_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 64, toUint64(v5_0), true);
-        dataView(memory0).setInt32(arg1 + 72, toUint32(v5_1), true);
+        const {seconds: v6_0, nanoseconds: v6_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 64, toUint64(v6_0), true);
+        dataView(memory0).setInt32(arg1 + 72, toUint32(v6_1), true);
       }
-      const variant8 = v1_5;
-      if (variant8 === null || variant8=== undefined) {
+      const variant9 = v2_5;
+      if (variant9 === null || variant9=== undefined) {
         dataView(memory0).setInt8(arg1 + 80, 0, true);
       } else {
-        const e = variant8;
+        const e = variant9;
         dataView(memory0).setInt8(arg1 + 80, 1, true);
-        const {seconds: v7_0, nanoseconds: v7_1 } = e;
-        dataView(memory0).setBigInt64(arg1 + 88, toUint64(v7_0), true);
-        dataView(memory0).setInt32(arg1 + 96, toUint32(v7_1), true);
+        const {seconds: v8_0, nanoseconds: v8_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 88, toUint64(v8_0), true);
+        dataView(memory0).setInt32(arg1 + 96, toUint32(v8_1), true);
       }
       break;
     }
     case 'err': {
-      const e = variant10.val;
+      const e = variant11.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val9 = e;
-      let enum9;
-      switch (val9) {
+      const val10 = e;
+      let enum10;
+      switch (val10) {
         case 'access': {
-          enum9 = 0;
+          enum10 = 0;
           break;
         }
         case 'would-block': {
-          enum9 = 1;
+          enum10 = 1;
           break;
         }
         case 'already': {
-          enum9 = 2;
+          enum10 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum9 = 3;
+          enum10 = 3;
           break;
         }
         case 'busy': {
-          enum9 = 4;
+          enum10 = 4;
           break;
         }
         case 'deadlock': {
-          enum9 = 5;
+          enum10 = 5;
           break;
         }
         case 'quota': {
-          enum9 = 6;
+          enum10 = 6;
           break;
         }
         case 'exist': {
-          enum9 = 7;
+          enum10 = 7;
           break;
         }
         case 'file-too-large': {
-          enum9 = 8;
+          enum10 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum9 = 9;
+          enum10 = 9;
           break;
         }
         case 'in-progress': {
-          enum9 = 10;
+          enum10 = 10;
           break;
         }
         case 'interrupted': {
-          enum9 = 11;
+          enum10 = 11;
           break;
         }
         case 'invalid': {
-          enum9 = 12;
+          enum10 = 12;
           break;
         }
         case 'io': {
-          enum9 = 13;
+          enum10 = 13;
           break;
         }
         case 'is-directory': {
-          enum9 = 14;
+          enum10 = 14;
           break;
         }
         case 'loop': {
-          enum9 = 15;
+          enum10 = 15;
           break;
         }
         case 'too-many-links': {
-          enum9 = 16;
+          enum10 = 16;
           break;
         }
         case 'message-size': {
-          enum9 = 17;
+          enum10 = 17;
           break;
         }
         case 'name-too-long': {
-          enum9 = 18;
+          enum10 = 18;
           break;
         }
         case 'no-device': {
-          enum9 = 19;
+          enum10 = 19;
           break;
         }
         case 'no-entry': {
-          enum9 = 20;
+          enum10 = 20;
           break;
         }
         case 'no-lock': {
-          enum9 = 21;
+          enum10 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum9 = 22;
+          enum10 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum9 = 23;
+          enum10 = 23;
           break;
         }
         case 'not-directory': {
-          enum9 = 24;
+          enum10 = 24;
           break;
         }
         case 'not-empty': {
-          enum9 = 25;
+          enum10 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum9 = 26;
+          enum10 = 26;
           break;
         }
         case 'unsupported': {
-          enum9 = 27;
+          enum10 = 27;
           break;
         }
         case 'no-tty': {
-          enum9 = 28;
+          enum10 = 28;
           break;
         }
         case 'no-such-device': {
-          enum9 = 29;
+          enum10 = 29;
           break;
         }
         case 'overflow': {
-          enum9 = 30;
+          enum10 = 30;
           break;
         }
         case 'not-permitted': {
-          enum9 = 31;
+          enum10 = 31;
           break;
         }
         case 'pipe': {
-          enum9 = 32;
+          enum10 = 32;
           break;
         }
         case 'read-only': {
-          enum9 = 33;
+          enum10 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum9 = 34;
+          enum10 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum9 = 35;
+          enum10 = 35;
           break;
         }
         case 'cross-device': {
-          enum9 = 36;
+          enum10 = 36;
           break;
         }
         default: {
@@ -1235,10 +1242,10 @@ function trampoline17(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val9}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val10}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum9, true);
+      dataView(memory0).setInt8(arg1 + 8, enum10, true);
       break;
     }
     default: {
@@ -1248,20 +1255,21 @@ function trampoline17(arg0, arg1) {
 }
 
 function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable3.get(handle1).rep;
   if ((arg1 & 4294967294) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags1 = {
+  const flags2 = {
     symlinkFollow: Boolean(arg1 & 1),
   };
-  const ptr2 = arg2;
-  const len2 = arg3;
-  const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+  const ptr3 = arg2;
+  const len3 = arg3;
+  const result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
   if ((arg4 & 4294967280) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags3 = {
+  const flags4 = {
     create: Boolean(arg4 & 1),
     directory: Boolean(arg4 & 2),
     exclusive: Boolean(arg4 & 4),
@@ -1270,7 +1278,7 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
   if ((arg5 & 4294967232) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags4 = {
+  const flags5 = {
     read: Boolean(arg5 & 1),
     write: Boolean(arg5 & 2),
     fileIntegritySync: Boolean(arg5 & 4),
@@ -1281,182 +1289,182 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
   if ((arg6 & 4294967288) !== 0) {
     throw new TypeError('flags have extraneous bits set');
   }
-  const flags5 = {
+  const flags6 = {
     readable: Boolean(arg6 & 1),
     writable: Boolean(arg6 & 2),
     executable: Boolean(arg6 & 4),
   };
   let ret;
   try {
-    ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags1, result2, flags3, flags4, flags5) };
+    ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags2, result3, flags4, flags5, flags6) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant8 = ret;
-  switch (variant8.tag) {
+  const variant9 = ret;
+  switch (variant9.tag) {
     case 'ok': {
-      const e = variant8.val;
+      const e = variant9.val;
       dataView(memory0).setInt8(arg7 + 0, 0, true);
       if (!(e instanceof Descriptor)) {
         throw new Error('Not a valid "Descriptor" resource.');
       }
-      const handle6 = handleCnt3++;
-      handleTable3.set(handle6, { rep: e, own: true });
-      dataView(memory0).setInt32(arg7 + 4, handle6, true);
+      const handle7 = handleCnt3++;
+      handleTable3.set(handle7, { rep: e, own: true });
+      dataView(memory0).setInt32(arg7 + 4, handle7, true);
       break;
     }
     case 'err': {
-      const e = variant8.val;
+      const e = variant9.val;
       dataView(memory0).setInt8(arg7 + 0, 1, true);
-      const val7 = e;
-      let enum7;
-      switch (val7) {
+      const val8 = e;
+      let enum8;
+      switch (val8) {
         case 'access': {
-          enum7 = 0;
+          enum8 = 0;
           break;
         }
         case 'would-block': {
-          enum7 = 1;
+          enum8 = 1;
           break;
         }
         case 'already': {
-          enum7 = 2;
+          enum8 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum7 = 3;
+          enum8 = 3;
           break;
         }
         case 'busy': {
-          enum7 = 4;
+          enum8 = 4;
           break;
         }
         case 'deadlock': {
-          enum7 = 5;
+          enum8 = 5;
           break;
         }
         case 'quota': {
-          enum7 = 6;
+          enum8 = 6;
           break;
         }
         case 'exist': {
-          enum7 = 7;
+          enum8 = 7;
           break;
         }
         case 'file-too-large': {
-          enum7 = 8;
+          enum8 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum7 = 9;
+          enum8 = 9;
           break;
         }
         case 'in-progress': {
-          enum7 = 10;
+          enum8 = 10;
           break;
         }
         case 'interrupted': {
-          enum7 = 11;
+          enum8 = 11;
           break;
         }
         case 'invalid': {
-          enum7 = 12;
+          enum8 = 12;
           break;
         }
         case 'io': {
-          enum7 = 13;
+          enum8 = 13;
           break;
         }
         case 'is-directory': {
-          enum7 = 14;
+          enum8 = 14;
           break;
         }
         case 'loop': {
-          enum7 = 15;
+          enum8 = 15;
           break;
         }
         case 'too-many-links': {
-          enum7 = 16;
+          enum8 = 16;
           break;
         }
         case 'message-size': {
-          enum7 = 17;
+          enum8 = 17;
           break;
         }
         case 'name-too-long': {
-          enum7 = 18;
+          enum8 = 18;
           break;
         }
         case 'no-device': {
-          enum7 = 19;
+          enum8 = 19;
           break;
         }
         case 'no-entry': {
-          enum7 = 20;
+          enum8 = 20;
           break;
         }
         case 'no-lock': {
-          enum7 = 21;
+          enum8 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum7 = 22;
+          enum8 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum7 = 23;
+          enum8 = 23;
           break;
         }
         case 'not-directory': {
-          enum7 = 24;
+          enum8 = 24;
           break;
         }
         case 'not-empty': {
-          enum7 = 25;
+          enum8 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum7 = 26;
+          enum8 = 26;
           break;
         }
         case 'unsupported': {
-          enum7 = 27;
+          enum8 = 27;
           break;
         }
         case 'no-tty': {
-          enum7 = 28;
+          enum8 = 28;
           break;
         }
         case 'no-such-device': {
-          enum7 = 29;
+          enum8 = 29;
           break;
         }
         case 'overflow': {
-          enum7 = 30;
+          enum8 = 30;
           break;
         }
         case 'not-permitted': {
-          enum7 = 31;
+          enum8 = 31;
           break;
         }
         case 'pipe': {
-          enum7 = 32;
+          enum8 = 32;
           break;
         }
         case 'read-only': {
-          enum7 = 33;
+          enum8 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum7 = 34;
+          enum8 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum7 = 35;
+          enum8 = 35;
           break;
         }
         case 'cross-device': {
-          enum7 = 36;
+          enum8 = 36;
           break;
         }
         default: {
@@ -1464,10 +1472,10 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val7}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val8}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg7 + 4, enum7, true);
+      dataView(memory0).setInt8(arg7 + 4, enum8, true);
       break;
     }
     default: {
@@ -1477,175 +1485,176 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
 }
 
 function trampoline19(arg0, arg1) {
-  const rsc0 = handleTable3.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable3.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: Descriptor.prototype.metadataHash.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
-      const {lower: v1_0, upper: v1_1 } = e;
-      dataView(memory0).setBigInt64(arg1 + 8, toUint64(v1_0), true);
-      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v1_1), true);
+      const {lower: v2_0, upper: v2_1 } = e;
+      dataView(memory0).setBigInt64(arg1 + 8, toUint64(v2_0), true);
+      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const val2 = e;
-      let enum2;
-      switch (val2) {
+      const val3 = e;
+      let enum3;
+      switch (val3) {
         case 'access': {
-          enum2 = 0;
+          enum3 = 0;
           break;
         }
         case 'would-block': {
-          enum2 = 1;
+          enum3 = 1;
           break;
         }
         case 'already': {
-          enum2 = 2;
+          enum3 = 2;
           break;
         }
         case 'bad-descriptor': {
-          enum2 = 3;
+          enum3 = 3;
           break;
         }
         case 'busy': {
-          enum2 = 4;
+          enum3 = 4;
           break;
         }
         case 'deadlock': {
-          enum2 = 5;
+          enum3 = 5;
           break;
         }
         case 'quota': {
-          enum2 = 6;
+          enum3 = 6;
           break;
         }
         case 'exist': {
-          enum2 = 7;
+          enum3 = 7;
           break;
         }
         case 'file-too-large': {
-          enum2 = 8;
+          enum3 = 8;
           break;
         }
         case 'illegal-byte-sequence': {
-          enum2 = 9;
+          enum3 = 9;
           break;
         }
         case 'in-progress': {
-          enum2 = 10;
+          enum3 = 10;
           break;
         }
         case 'interrupted': {
-          enum2 = 11;
+          enum3 = 11;
           break;
         }
         case 'invalid': {
-          enum2 = 12;
+          enum3 = 12;
           break;
         }
         case 'io': {
-          enum2 = 13;
+          enum3 = 13;
           break;
         }
         case 'is-directory': {
-          enum2 = 14;
+          enum3 = 14;
           break;
         }
         case 'loop': {
-          enum2 = 15;
+          enum3 = 15;
           break;
         }
         case 'too-many-links': {
-          enum2 = 16;
+          enum3 = 16;
           break;
         }
         case 'message-size': {
-          enum2 = 17;
+          enum3 = 17;
           break;
         }
         case 'name-too-long': {
-          enum2 = 18;
+          enum3 = 18;
           break;
         }
         case 'no-device': {
-          enum2 = 19;
+          enum3 = 19;
           break;
         }
         case 'no-entry': {
-          enum2 = 20;
+          enum3 = 20;
           break;
         }
         case 'no-lock': {
-          enum2 = 21;
+          enum3 = 21;
           break;
         }
         case 'insufficient-memory': {
-          enum2 = 22;
+          enum3 = 22;
           break;
         }
         case 'insufficient-space': {
-          enum2 = 23;
+          enum3 = 23;
           break;
         }
         case 'not-directory': {
-          enum2 = 24;
+          enum3 = 24;
           break;
         }
         case 'not-empty': {
-          enum2 = 25;
+          enum3 = 25;
           break;
         }
         case 'not-recoverable': {
-          enum2 = 26;
+          enum3 = 26;
           break;
         }
         case 'unsupported': {
-          enum2 = 27;
+          enum3 = 27;
           break;
         }
         case 'no-tty': {
-          enum2 = 28;
+          enum3 = 28;
           break;
         }
         case 'no-such-device': {
-          enum2 = 29;
+          enum3 = 29;
           break;
         }
         case 'overflow': {
-          enum2 = 30;
+          enum3 = 30;
           break;
         }
         case 'not-permitted': {
-          enum2 = 31;
+          enum3 = 31;
           break;
         }
         case 'pipe': {
-          enum2 = 32;
+          enum3 = 32;
           break;
         }
         case 'read-only': {
-          enum2 = 33;
+          enum3 = 33;
           break;
         }
         case 'invalid-seek': {
-          enum2 = 34;
+          enum3 = 34;
           break;
         }
         case 'text-file-busy': {
-          enum2 = 35;
+          enum3 = 35;
           break;
         }
         case 'cross-device': {
-          enum2 = 36;
+          enum3 = 36;
           break;
         }
         default: {
@@ -1653,10 +1662,10 @@ function trampoline19(arg0, arg1) {
             console.error(e);
           }
           
-          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
         }
       }
-      dataView(memory0).setInt8(arg1 + 8, enum2, true);
+      dataView(memory0).setInt8(arg1 + 8, enum3, true);
       break;
     }
     default: {
@@ -1666,163 +1675,164 @@ function trampoline19(arg0, arg1) {
 }
 
 function trampoline20(arg0, arg1) {
-  const rsc0 = handleTable1.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable1.get(handle1).rep;
   const ret = filesystemErrorCode(rsc0);
-  const variant2 = ret;
-  if (variant2 === null || variant2=== undefined) {
+  const variant3 = ret;
+  if (variant3 === null || variant3=== undefined) {
     dataView(memory0).setInt8(arg1 + 0, 0, true);
   } else {
-    const e = variant2;
+    const e = variant3;
     dataView(memory0).setInt8(arg1 + 0, 1, true);
-    const val1 = e;
-    let enum1;
-    switch (val1) {
+    const val2 = e;
+    let enum2;
+    switch (val2) {
       case 'access': {
-        enum1 = 0;
+        enum2 = 0;
         break;
       }
       case 'would-block': {
-        enum1 = 1;
+        enum2 = 1;
         break;
       }
       case 'already': {
-        enum1 = 2;
+        enum2 = 2;
         break;
       }
       case 'bad-descriptor': {
-        enum1 = 3;
+        enum2 = 3;
         break;
       }
       case 'busy': {
-        enum1 = 4;
+        enum2 = 4;
         break;
       }
       case 'deadlock': {
-        enum1 = 5;
+        enum2 = 5;
         break;
       }
       case 'quota': {
-        enum1 = 6;
+        enum2 = 6;
         break;
       }
       case 'exist': {
-        enum1 = 7;
+        enum2 = 7;
         break;
       }
       case 'file-too-large': {
-        enum1 = 8;
+        enum2 = 8;
         break;
       }
       case 'illegal-byte-sequence': {
-        enum1 = 9;
+        enum2 = 9;
         break;
       }
       case 'in-progress': {
-        enum1 = 10;
+        enum2 = 10;
         break;
       }
       case 'interrupted': {
-        enum1 = 11;
+        enum2 = 11;
         break;
       }
       case 'invalid': {
-        enum1 = 12;
+        enum2 = 12;
         break;
       }
       case 'io': {
-        enum1 = 13;
+        enum2 = 13;
         break;
       }
       case 'is-directory': {
-        enum1 = 14;
+        enum2 = 14;
         break;
       }
       case 'loop': {
-        enum1 = 15;
+        enum2 = 15;
         break;
       }
       case 'too-many-links': {
-        enum1 = 16;
+        enum2 = 16;
         break;
       }
       case 'message-size': {
-        enum1 = 17;
+        enum2 = 17;
         break;
       }
       case 'name-too-long': {
-        enum1 = 18;
+        enum2 = 18;
         break;
       }
       case 'no-device': {
-        enum1 = 19;
+        enum2 = 19;
         break;
       }
       case 'no-entry': {
-        enum1 = 20;
+        enum2 = 20;
         break;
       }
       case 'no-lock': {
-        enum1 = 21;
+        enum2 = 21;
         break;
       }
       case 'insufficient-memory': {
-        enum1 = 22;
+        enum2 = 22;
         break;
       }
       case 'insufficient-space': {
-        enum1 = 23;
+        enum2 = 23;
         break;
       }
       case 'not-directory': {
-        enum1 = 24;
+        enum2 = 24;
         break;
       }
       case 'not-empty': {
-        enum1 = 25;
+        enum2 = 25;
         break;
       }
       case 'not-recoverable': {
-        enum1 = 26;
+        enum2 = 26;
         break;
       }
       case 'unsupported': {
-        enum1 = 27;
+        enum2 = 27;
         break;
       }
       case 'no-tty': {
-        enum1 = 28;
+        enum2 = 28;
         break;
       }
       case 'no-such-device': {
-        enum1 = 29;
+        enum2 = 29;
         break;
       }
       case 'overflow': {
-        enum1 = 30;
+        enum2 = 30;
         break;
       }
       case 'not-permitted': {
-        enum1 = 31;
+        enum2 = 31;
         break;
       }
       case 'pipe': {
-        enum1 = 32;
+        enum2 = 32;
         break;
       }
       case 'read-only': {
-        enum1 = 33;
+        enum2 = 33;
         break;
       }
       case 'invalid-seek': {
-        enum1 = 34;
+        enum2 = 34;
         break;
       }
       case 'text-file-busy': {
-        enum1 = 35;
+        enum2 = 35;
         break;
       }
       case 'cross-device': {
-        enum1 = 36;
+        enum2 = 36;
         break;
       }
       default: {
@@ -1830,49 +1840,50 @@ function trampoline20(arg0, arg1) {
           console.error(e);
         }
         
-        throw new TypeError(`"${val1}" is not one of the cases of error-code`);
+        throw new TypeError(`"${val2}" is not one of the cases of error-code`);
       }
     }
-    dataView(memory0).setInt8(arg1 + 1, enum1, true);
+    dataView(memory0).setInt8(arg1 + 1, enum2, true);
   }
 }
 
 function trampoline21(arg0, arg1, arg2) {
-  const rsc0 = handleTable0.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable0.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: InputStream.prototype.read.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  const variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      const val1 = e;
-      const len1 = val1.byteLength;
-      const ptr1 = realloc0(0, 0, 1, len1 * 1);
-      const src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
-      (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
-      dataView(memory0).setInt32(arg2 + 8, len1, true);
-      dataView(memory0).setInt32(arg2 + 4, ptr1, true);
+      const val2 = e;
+      const len2 = val2.byteLength;
+      const ptr2 = realloc0(0, 0, 1, len2 * 1);
+      const src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+      (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
+      dataView(memory0).setInt32(arg2 + 8, len2, true);
+      dataView(memory0).setInt32(arg2 + 4, ptr2, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      const variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg2 + 4, 0, true);
           if (!(e instanceof Error$1)) {
             throw new Error('Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg2 + 8, handle2, true);
+          const handle3 = handleCnt1++;
+          handleTable1.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg2 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -1880,7 +1891,7 @@ function trampoline21(arg0, arg1, arg2) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant ${JSON.stringify(variant4.tag)} specified for StreamError`);
         }
       }
       break;
@@ -1892,41 +1903,42 @@ function trampoline21(arg0, arg1, arg2) {
 }
 
 function trampoline22(arg0, arg1, arg2) {
-  const rsc0 = handleTable0.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable0.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: InputStream.prototype.blockingRead.call(rsc0, BigInt.asUintN(64, arg1)) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  const variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 0, true);
-      const val1 = e;
-      const len1 = val1.byteLength;
-      const ptr1 = realloc0(0, 0, 1, len1 * 1);
-      const src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
-      (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
-      dataView(memory0).setInt32(arg2 + 8, len1, true);
-      dataView(memory0).setInt32(arg2 + 4, ptr1, true);
+      const val2 = e;
+      const len2 = val2.byteLength;
+      const ptr2 = realloc0(0, 0, 1, len2 * 1);
+      const src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+      (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
+      dataView(memory0).setInt32(arg2 + 8, len2, true);
+      dataView(memory0).setInt32(arg2 + 4, ptr2, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg2 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      const variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg2 + 4, 0, true);
           if (!(e instanceof Error$1)) {
             throw new Error('Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg2 + 8, handle2, true);
+          const handle3 = handleCnt1++;
+          handleTable1.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg2 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -1934,7 +1946,7 @@ function trampoline22(arg0, arg1, arg2) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant ${JSON.stringify(variant4.tag)} specified for StreamError`);
         }
       }
       break;
@@ -1946,35 +1958,36 @@ function trampoline22(arg0, arg1, arg2) {
 }
 
 function trampoline23(arg0, arg1) {
-  const rsc0 = handleTable2.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable2.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: OutputStream.prototype.checkWrite.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const variant2 = e;
-      switch (variant2.tag) {
+      const variant3 = e;
+      switch (variant3.tag) {
         case 'last-operation-failed': {
-          const e = variant2.val;
+          const e = variant3.val;
           dataView(memory0).setInt8(arg1 + 8, 0, true);
           if (!(e instanceof Error$1)) {
             throw new Error('Not a valid "Error" resource.');
           }
-          const handle1 = handleCnt1++;
-          handleTable1.set(handle1, { rep: e, own: true });
-          dataView(memory0).setInt32(arg1 + 12, handle1, true);
+          const handle2 = handleCnt1++;
+          handleTable1.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg1 + 12, handle2, true);
           break;
         }
         case 'closed': {
@@ -1982,7 +1995,7 @@ function trampoline23(arg0, arg1) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant ${JSON.stringify(variant3.tag)} specified for StreamError`);
         }
       }
       break;
@@ -1994,37 +2007,38 @@ function trampoline23(arg0, arg1) {
 }
 
 function trampoline24(arg0, arg1, arg2, arg3) {
-  const rsc0 = handleTable2.get(arg0).rep;
-  const ptr1 = arg1;
-  const len1 = arg2;
-  const result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
+  const handle1 = arg0;
+  const rsc0 = handleTable2.get(handle1).rep;
+  const ptr2 = arg1;
+  const len2 = arg2;
+  const result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
   let ret;
   try {
-    ret = { tag: 'ok', val: OutputStream.prototype.write.call(rsc0, result1) };
+    ret = { tag: 'ok', val: OutputStream.prototype.write.call(rsc0, result2) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  const variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      const variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg3 + 4, 0, true);
           if (!(e instanceof Error$1)) {
             throw new Error('Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg3 + 8, handle2, true);
+          const handle3 = handleCnt1++;
+          handleTable1.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg3 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -2032,7 +2046,7 @@ function trampoline24(arg0, arg1, arg2, arg3) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant ${JSON.stringify(variant4.tag)} specified for StreamError`);
         }
       }
       break;
@@ -2044,37 +2058,38 @@ function trampoline24(arg0, arg1, arg2, arg3) {
 }
 
 function trampoline25(arg0, arg1, arg2, arg3) {
-  const rsc0 = handleTable2.get(arg0).rep;
-  const ptr1 = arg1;
-  const len1 = arg2;
-  const result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
+  const handle1 = arg0;
+  const rsc0 = handleTable2.get(handle1).rep;
+  const ptr2 = arg1;
+  const len2 = arg2;
+  const result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
   let ret;
   try {
-    ret = { tag: 'ok', val: OutputStream.prototype.blockingWriteAndFlush.call(rsc0, result1) };
+    ret = { tag: 'ok', val: OutputStream.prototype.blockingWriteAndFlush.call(rsc0, result2) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant4 = ret;
-  switch (variant4.tag) {
+  const variant5 = ret;
+  switch (variant5.tag) {
     case 'ok': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant4.val;
+      const e = variant5.val;
       dataView(memory0).setInt8(arg3 + 0, 1, true);
-      const variant3 = e;
-      switch (variant3.tag) {
+      const variant4 = e;
+      switch (variant4.tag) {
         case 'last-operation-failed': {
-          const e = variant3.val;
+          const e = variant4.val;
           dataView(memory0).setInt8(arg3 + 4, 0, true);
           if (!(e instanceof Error$1)) {
             throw new Error('Not a valid "Error" resource.');
           }
-          const handle2 = handleCnt1++;
-          handleTable1.set(handle2, { rep: e, own: true });
-          dataView(memory0).setInt32(arg3 + 8, handle2, true);
+          const handle3 = handleCnt1++;
+          handleTable1.set(handle3, { rep: e, own: true });
+          dataView(memory0).setInt32(arg3 + 8, handle3, true);
           break;
         }
         case 'closed': {
@@ -2082,7 +2097,7 @@ function trampoline25(arg0, arg1, arg2, arg3) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant ${JSON.stringify(variant4.tag)} specified for StreamError`);
         }
       }
       break;
@@ -2094,34 +2109,35 @@ function trampoline25(arg0, arg1, arg2, arg3) {
 }
 
 function trampoline26(arg0, arg1) {
-  const rsc0 = handleTable2.get(arg0).rep;
+  const handle1 = arg0;
+  const rsc0 = handleTable2.get(handle1).rep;
   let ret;
   try {
     ret = { tag: 'ok', val: OutputStream.prototype.blockingFlush.call(rsc0) };
   } catch (e) {
     ret = { tag: 'err', val: getErrorPayload(e) };
   }
-  const variant3 = ret;
-  switch (variant3.tag) {
+  const variant4 = ret;
+  switch (variant4.tag) {
     case 'ok': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 0, true);
       break;
     }
     case 'err': {
-      const e = variant3.val;
+      const e = variant4.val;
       dataView(memory0).setInt8(arg1 + 0, 1, true);
-      const variant2 = e;
-      switch (variant2.tag) {
+      const variant3 = e;
+      switch (variant3.tag) {
         case 'last-operation-failed': {
-          const e = variant2.val;
+          const e = variant3.val;
           dataView(memory0).setInt8(arg1 + 4, 0, true);
           if (!(e instanceof Error$1)) {
             throw new Error('Not a valid "Error" resource.');
           }
-          const handle1 = handleCnt1++;
-          handleTable1.set(handle1, { rep: e, own: true });
-          dataView(memory0).setInt32(arg1 + 8, handle1, true);
+          const handle2 = handleCnt1++;
+          handleTable1.set(handle2, { rep: e, own: true });
+          dataView(memory0).setInt32(arg1 + 8, handle2, true);
           break;
         }
         case 'closed': {
@@ -2129,7 +2145,7 @@ function trampoline26(arg0, arg1) {
           break;
         }
         default: {
-          throw new TypeError('invalid variant specified for StreamError');
+          throw new TypeError(`invalid variant ${JSON.stringify(variant3.tag)} specified for StreamError`);
         }
       }
       break;
@@ -2234,6 +2250,9 @@ function trampoline0(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable4.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 const handleTable1= new Map();
 let handleCnt1 = 0;
@@ -2243,6 +2262,9 @@ function trampoline1(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable1.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 const handleTable0= new Map();
 let handleCnt0 = 0;
@@ -2252,6 +2274,9 @@ function trampoline2(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable0.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 const handleTable2= new Map();
 let handleCnt2 = 0;
@@ -2261,6 +2286,9 @@ function trampoline3(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable2.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 const handleTable3= new Map();
 let handleCnt3 = 0;
@@ -2270,6 +2298,9 @@ function trampoline4(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable3.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 const handleTable5= new Map();
 let handleCnt5 = 0;
@@ -2279,6 +2310,9 @@ function trampoline5(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable5.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 const handleTable6= new Map();
 let handleCnt6 = 0;
@@ -2288,6 +2322,9 @@ function trampoline6(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable6.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 const handleTable7= new Map();
 let handleCnt7 = 0;
@@ -2297,6 +2334,9 @@ function trampoline7(handle) {
     throw new Error(`Resource error: Invalid handle ${handle}`);
   }
   handleTable7.delete(handle);
+  if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+    handleEntry.rep[symbolDispose]();
+  }
 }
 
 function parse(arg0) {