@bytecodealliance/jco 0.6.0 → 0.7.0

package/api.mjs

@@ -6578,6 +6578,20 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("fs/promises"
 
 /***/ }),
 
+/***/ 6005:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:crypto");
+
+/***/ }),
+
+/***/ 7561:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs");
+
+/***/ }),
+
 /***/ 612:
 /***/ ((module) => {
 
@@ -6632,24 +6646,6 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("url");
 
 module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("util");
 
-/***/ }),
-
-/***/ 2759:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
-
-/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
-/* harmony export */   "v": () => (/* binding */ error)
-/* harmony export */ });
-/* unused harmony export log */
-function log(msg) {
-  console.log(msg);
-}
-
-function error(msg) {
-  console.error(msg);
-}
-
-
 /***/ }),
 
 /***/ 267:
@@ -40037,47 +40033,20 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
 /* harmony export */   "I": () => (/* binding */ exports)
 /* harmony export */ });
-/* harmony import */ var _lib_console_js__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(2759);
+/* harmony import */ var _bytecodealliance_preview2_shim_exit__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(7393);
+/* harmony import */ var _bytecodealliance_preview2_shim_random__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(8576);
+/* harmony import */ var _bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(5331);
+/* harmony import */ var _bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(9213);
+/* harmony import */ var _bytecodealliance_preview2_shim_preopens__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(833);
+/* harmony import */ var _bytecodealliance_preview2_shim_environment__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(9187);
 
 
-const instantiateCore = WebAssembly.instantiate;
 
-const utf8Decoder = new TextDecoder();
 
-let dv = new DataView(new ArrayBuffer());
-const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
 
-const utf8Encoder = new TextEncoder();
 
-let utf8EncodedLen = 0;
-function utf8Encode(s, realloc, memory) {
-  if (typeof s !== 'string') throw new TypeError('expected a string');
-  if (s.length === 0) {
-    utf8EncodedLen = 0;
-    return 1;
-  }
-  let allocLen = 0;
-  let ptr = 0;
-  let writtenTotal = 0;
-  while (s.length > 0) {
-    ptr = realloc(ptr, allocLen, 1, allocLen + s.length);
-    allocLen += s.length;
-    const { read, written } = utf8Encoder.encodeInto(
-    s,
-    new Uint8Array(memory.buffer, ptr + writtenTotal, allocLen - writtenTotal),
-    );
-    writtenTotal += written;
-    s = s.slice(read);
-  }
-  if (allocLen > writtenTotal)
-  ptr = realloc(ptr, allocLen, 1, writtenTotal);
-  utf8EncodedLen = writtenTotal;
-  return ptr;
-}
 
-function toUint32(val) {
-  return val >>> 0;
-}
+const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
 
 class ComponentError extends Error {
   constructor (value) {
@@ -40087,6 +40056,9 @@ class ComponentError extends Error {
   }
 }
 
+let dv = new DataView(new ArrayBuffer());
+const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+
 const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
 let _fs;
 async function fetchCompile (url) {
@@ -40097,242 +40069,26 @@ async function fetchCompile (url) {
   return fetch(url).then(WebAssembly.compileStreaming);
 }
 
-const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
-
-let exports0;
-let exports1;
-let memory0;
-
-function lowering0(arg0, arg1) {
-  const ptr0 = arg0;
-  const len0 = arg1;
-  const result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-  (0,_lib_console_js__WEBPACK_IMPORTED_MODULE_0__/* .error */ .v)(result0);
+function getErrorPayload(e) {
+  if (hasOwnProperty.call(e, 'payload')) return e.payload;
+  if (hasOwnProperty.call(e, 'message')) return String(e.message);
+  return String(e);
 }
-let exports2;
-let realloc0;
-let postReturn0;
-const exports = {
-  generate(arg0, arg1) {
-    const ptr0 = realloc0(0, 0, 4, 48);
-    const val1 = arg0;
-    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(ptr0 + 4, len1, true);
-    dataView(memory0).setInt32(ptr0 + 0, ptr1, true);
-    const {name: v2_0, noTypescript: v2_1, instantiation: v2_2, map: v2_3, compat: v2_4, noNodejsCompat: v2_5, base64Cutoff: v2_6, tlaCompat: v2_7, validLiftingOptimization: v2_8 } = arg1;
-    const ptr3 = utf8Encode(v2_0, realloc0, memory0);
-    const len3 = utf8EncodedLen;
-    dataView(memory0).setInt32(ptr0 + 12, len3, true);
-    dataView(memory0).setInt32(ptr0 + 8, ptr3, true);
-    const variant4 = v2_1;
-    if (variant4 === null || variant4=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 16, 0, true);
-    } else {
-      const e = variant4;
-      dataView(memory0).setInt8(ptr0 + 16, 1, true);
-      dataView(memory0).setInt8(ptr0 + 17, e ? 1 : 0, true);
-    }
-    const variant5 = v2_2;
-    if (variant5 === null || variant5=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 18, 0, true);
-    } else {
-      const e = variant5;
-      dataView(memory0).setInt8(ptr0 + 18, 1, true);
-      dataView(memory0).setInt8(ptr0 + 19, e ? 1 : 0, true);
-    }
-    const variant10 = v2_3;
-    if (variant10 === null || variant10=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 20, 0, true);
-    } else {
-      const e = variant10;
-      dataView(memory0).setInt8(ptr0 + 20, 1, true);
-      const vec9 = e;
-      const len9 = vec9.length;
-      const result9 = realloc0(0, 0, 4, len9 * 16);
-      for (let i = 0; i < vec9.length; i++) {
-        const e = vec9[i];
-        const base = result9 + i * 16;const [tuple6_0, tuple6_1] = e;
-        const ptr7 = utf8Encode(tuple6_0, realloc0, memory0);
-        const len7 = utf8EncodedLen;
-        dataView(memory0).setInt32(base + 4, len7, true);
-        dataView(memory0).setInt32(base + 0, ptr7, true);
-        const ptr8 = utf8Encode(tuple6_1, realloc0, memory0);
-        const len8 = utf8EncodedLen;
-        dataView(memory0).setInt32(base + 12, len8, true);
-        dataView(memory0).setInt32(base + 8, ptr8, true);
-      }
-      dataView(memory0).setInt32(ptr0 + 28, len9, true);
-      dataView(memory0).setInt32(ptr0 + 24, result9, true);
-    }
-    const variant11 = v2_4;
-    if (variant11 === null || variant11=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 32, 0, true);
-    } else {
-      const e = variant11;
-      dataView(memory0).setInt8(ptr0 + 32, 1, true);
-      dataView(memory0).setInt8(ptr0 + 33, e ? 1 : 0, true);
-    }
-    const variant12 = v2_5;
-    if (variant12 === null || variant12=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 34, 0, true);
-    } else {
-      const e = variant12;
-      dataView(memory0).setInt8(ptr0 + 34, 1, true);
-      dataView(memory0).setInt8(ptr0 + 35, e ? 1 : 0, true);
-    }
-    const variant13 = v2_6;
-    if (variant13 === null || variant13=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 36, 0, true);
-    } else {
-      const e = variant13;
-      dataView(memory0).setInt8(ptr0 + 36, 1, true);
-      dataView(memory0).setInt32(ptr0 + 40, toUint32(e), true);
-    }
-    const variant14 = v2_7;
-    if (variant14 === null || variant14=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 44, 0, true);
-    } else {
-      const e = variant14;
-      dataView(memory0).setInt8(ptr0 + 44, 1, true);
-      dataView(memory0).setInt8(ptr0 + 45, e ? 1 : 0, true);
-    }
-    const variant15 = v2_8;
-    if (variant15 === null || variant15=== undefined) {
-      dataView(memory0).setInt8(ptr0 + 46, 0, true);
-    } else {
-      const e = variant15;
-      dataView(memory0).setInt8(ptr0 + 46, 1, true);
-      dataView(memory0).setInt8(ptr0 + 47, e ? 1 : 0, true);
-    }
-    const ret = exports1['exports#generate'](ptr0);
-    let variant25;
-    switch (dataView(memory0).getUint8(ret + 0, true)) {
-      case 0: {
-        const len18 = dataView(memory0).getInt32(ret + 8, true);
-        const base18 = dataView(memory0).getInt32(ret + 4, true);
-        const result18 = [];
-        for (let i = 0; i < len18; i++) {
-          const base = base18 + i * 16;
-          const ptr16 = dataView(memory0).getInt32(base + 0, true);
-          const len16 = dataView(memory0).getInt32(base + 4, true);
-          const result16 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr16, len16));
-          const ptr17 = dataView(memory0).getInt32(base + 8, true);
-          const len17 = dataView(memory0).getInt32(base + 12, true);
-          const result17 = new Uint8Array(memory0.buffer.slice(ptr17, ptr17 + len17 * 1));
-          result18.push([result16, result17]);
-        }
-        const len20 = dataView(memory0).getInt32(ret + 16, true);
-        const base20 = dataView(memory0).getInt32(ret + 12, true);
-        const result20 = [];
-        for (let i = 0; i < len20; i++) {
-          const base = base20 + i * 8;
-          const ptr19 = dataView(memory0).getInt32(base + 0, true);
-          const len19 = dataView(memory0).getInt32(base + 4, true);
-          const result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
-          result20.push(result19);
-        }
-        const len23 = dataView(memory0).getInt32(ret + 24, true);
-        const base23 = dataView(memory0).getInt32(ret + 20, true);
-        const result23 = [];
-        for (let i = 0; i < len23; i++) {
-          const base = base23 + i * 12;
-          const ptr21 = dataView(memory0).getInt32(base + 0, true);
-          const len21 = dataView(memory0).getInt32(base + 4, true);
-          const result21 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr21, len21));
-          let enum22;
-          switch (dataView(memory0).getUint8(base + 8, true)) {
-            case 0: {
-              enum22 = 'function';
-              break;
-            }
-            case 1: {
-              enum22 = 'instance';
-              break;
-            }
-            default: {
-              throw new TypeError('invalid discriminant specified for ExportType');
-            }
-          }
-          result23.push([result21, enum22]);
-        }
-        variant25= {
-          tag: 'ok',
-          val: {
-            files: result18,
-            imports: result20,
-            exports: result23,
-          }
-        };
-        break;
-      }
-      case 1: {
-        const ptr24 = dataView(memory0).getInt32(ret + 4, true);
-        const len24 = dataView(memory0).getInt32(ret + 8, true);
-        const result24 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr24, len24));
-        variant25= {
-          tag: 'err',
-          val: result24
-        };
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant discriminant for expected');
-      }
-    }
-    postReturn0(ret);
-    if (variant25.tag === 'err') {
-      throw new ComponentError(variant25.val);
-    }
-    return variant25.val;
-  },
-  
-};
 
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 
+const instantiateCore = WebAssembly.instantiate;
 
-const $init = (async() => {
-  const module0 = fetchCompile(__nccwpck_require__.ab + "js-component-bindgen-component.core.wasm");
-  const module1 = base64Compile('AGFzbQEAAAABBgFgAn9/AAMCAQAEBQFwAQEBBxACATAAAAgkaW1wb3J0cwEACg0BCwAgACABQQARAAALAC0JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQFMC44LjEANQRuYW1lABMSd2l0LWNvbXBvbmVudDpzaGltARkBABZpbmRpcmVjdC1jb25zb2xlLWVycm9y');
-  const module2 = base64Compile('AGFzbQEAAAABBgFgAn9/AAIVAgABMAAAAAgkaW1wb3J0cwFwAQEBCQcBAEEACwEAAC0JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQFMC44LjEAHARuYW1lABUUd2l0LWNvbXBvbmVudDpmaXh1cHM=');
-  Promise.all([module0, module1, module2]).catch(() => {});
-  ({ exports: exports0 } = await instantiateCore(await module1));
-  ({ exports: exports1 } = await instantiateCore(await module0, {
-    console: {
-      error: exports0['0'],
-    },
-  }));
-  memory0 = exports1.memory;
-  ({ exports: exports2 } = await instantiateCore(await module2, {
-    '': {
-      $imports: exports0.$imports,
-      '0': lowering0,
-    },
-  }));
-  realloc0 = exports1.cabi_realloc;
-  postReturn0 = exports1['cabi_post_exports#generate'];
-})();
-
-await $init;
-
-__webpack_async_result__();
-} catch(e) { __webpack_async_result__(e); } }, 1);
-
-/***/ }),
-
-/***/ 8980:
-/***/ ((__webpack_module__, __webpack_exports__, __nccwpck_require__) => {
-
-__nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
-/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
-/* harmony export */   "I": () => (/* binding */ exports)
-/* harmony export */ });
-/* harmony import */ var _lib_console_js__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(2759);
+const toUint64 = val => BigInt.asUintN(64, val);
 
+function toString(val) {
+  if (typeof val === 'symbol') throw new TypeError('symbols cannot be converted to strings');
+  return String(val);
+}
 
-const instantiateCore = WebAssembly.instantiate;
+function toUint32(val) {
+  return val >>> 0;
+}
 
 const utf8Decoder = new TextDecoder();
 
@@ -40364,8 +40120,680 @@ function utf8Encode(s, realloc, memory) {
   return ptr;
 }
 
-let dv = new DataView(new ArrayBuffer());
-const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+let exports0;
+let exports1;
+
+function lowering0(arg0, arg1) {
+  const ret = (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_1__/* .writeViaStream */ .Zw)(arg0 >>> 0, BigInt.asUintN(64, arg1));
+  return toUint32(ret);
+}
+
+function lowering1(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_1__/* .appendViaStream */ .Tk)(arg0 >>> 0);
+  return toUint32(ret);
+}
+
+function lowering2(arg0) {
+  (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_1__/* .dropDescriptor */ .Lk)(arg0 >>> 0);
+}
+
+function lowering3(arg0) {
+  let variant0;
+  switch (arg0) {
+    case 0: {
+      variant0= {
+        tag: 'ok',
+        val: undefined
+      };
+      break;
+    }
+    case 1: {
+      variant0= {
+        tag: 'err',
+        val: undefined
+      };
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant discriminant for expected');
+    }
+  }
+  (0,_bytecodealliance_preview2_shim_exit__WEBPACK_IMPORTED_MODULE_5__/* .exit */ .J)(variant0);
+}
+
+function lowering4(arg0) {
+  (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_2__/* .dropInputStream */ .dU)(arg0 >>> 0);
+}
+
+function lowering5(arg0) {
+  (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_2__/* .dropOutputStream */ .oc)(arg0 >>> 0);
+}
+let exports2;
+let memory0;
+
+function lowering6(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_preopens__WEBPACK_IMPORTED_MODULE_3__/* .getStdio */ .vT)();
+  const {stdin: v0_0, stdout: v0_1, stderr: v0_2 } = ret;
+  dataView(memory0).setInt32(arg0 + 0, toUint32(v0_0), true);
+  dataView(memory0).setInt32(arg0 + 4, toUint32(v0_1), true);
+  dataView(memory0).setInt32(arg0 + 8, toUint32(v0_2), true);
+}
+let realloc0;
+
+function lowering7(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_preopens__WEBPACK_IMPORTED_MODULE_3__/* .getDirectories */ .$z)();
+  const vec2 = ret;
+  const len2 = vec2.length;
+  const result2 = realloc0(0, 0, 4, len2 * 12);
+  for (let i = 0; i < vec2.length; i++) {
+    const e = vec2[i];
+    const base = result2 + i * 12;const [tuple0_0, tuple0_1] = e;
+    dataView(memory0).setInt32(base + 0, toUint32(tuple0_0), true);
+    const ptr1 = utf8Encode(tuple0_1, realloc0, memory0);
+    const len1 = utf8EncodedLen;
+    dataView(memory0).setInt32(base + 8, len1, true);
+    dataView(memory0).setInt32(base + 4, ptr1, true);
+  }
+  dataView(memory0).setInt32(arg0 + 4, len2, true);
+  dataView(memory0).setInt32(arg0 + 0, result2, true);
+}
+
+function lowering8(arg0, arg1) {
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_1__/* .getType */ .oL)(arg0 >>> 0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant2 = ret;
+  switch (variant2.tag) {
+    case 'ok': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg1 + 0, 0, true);
+      const val0 = toString(e);
+      let enum0;
+      switch (val0) {
+        case 'unknown': {
+          enum0 = 0;
+          break;
+        }
+        case 'block-device': {
+          enum0 = 1;
+          break;
+        }
+        case 'character-device': {
+          enum0 = 2;
+          break;
+        }
+        case 'directory': {
+          enum0 = 3;
+          break;
+        }
+        case 'fifo': {
+          enum0 = 4;
+          break;
+        }
+        case 'symbolic-link': {
+          enum0 = 5;
+          break;
+        }
+        case 'regular-file': {
+          enum0 = 6;
+          break;
+        }
+        case 'socket': {
+          enum0 = 7;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val0}" is not one of the cases of descriptor-type`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 1, enum0, true);
+      break;
+    }
+    case 'err': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      const val1 = toString(e);
+      let enum1;
+      switch (val1) {
+        case 'access': {
+          enum1 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum1 = 1;
+          break;
+        }
+        case 'already': {
+          enum1 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum1 = 3;
+          break;
+        }
+        case 'busy': {
+          enum1 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum1 = 5;
+          break;
+        }
+        case 'quota': {
+          enum1 = 6;
+          break;
+        }
+        case 'exist': {
+          enum1 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum1 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum1 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum1 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum1 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum1 = 12;
+          break;
+        }
+        case 'io': {
+          enum1 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum1 = 14;
+          break;
+        }
+        case 'loop': {
+          enum1 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum1 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum1 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum1 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum1 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum1 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum1 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum1 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum1 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum1 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum1 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum1 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum1 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum1 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum1 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum1 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum1 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum1 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum1 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum1 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum1 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum1 = 36;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val1}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 1, enum1, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering9(arg0, arg1) {
+  const ret = (0,_bytecodealliance_preview2_shim_random__WEBPACK_IMPORTED_MODULE_0__/* .getRandomBytes */ .Iv)(BigInt.asUintN(64, arg0));
+  const val0 = ret;
+  const len0 = val0.byteLength;
+  const ptr0 = realloc0(0, 0, 1, len0 * 1);
+  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
+  dataView(memory0).setInt32(arg1 + 4, len0, true);
+  dataView(memory0).setInt32(arg1 + 0, ptr0, true);
+}
+
+function lowering10(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_environment__WEBPACK_IMPORTED_MODULE_4__/* .getEnvironment */ .zj)();
+  const vec3 = ret;
+  const len3 = vec3.length;
+  const result3 = realloc0(0, 0, 4, len3 * 16);
+  for (let i = 0; i < vec3.length; i++) {
+    const e = vec3[i];
+    const base = result3 + i * 16;const [tuple0_0, tuple0_1] = e;
+    const ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
+    const len1 = utf8EncodedLen;
+    dataView(memory0).setInt32(base + 4, len1, true);
+    dataView(memory0).setInt32(base + 0, ptr1, true);
+    const ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+    const len2 = utf8EncodedLen;
+    dataView(memory0).setInt32(base + 12, len2, true);
+    dataView(memory0).setInt32(base + 8, ptr2, true);
+  }
+  dataView(memory0).setInt32(arg0 + 4, len3, true);
+  dataView(memory0).setInt32(arg0 + 0, result3, true);
+}
+
+function lowering11(arg0, arg1, arg2, arg3) {
+  const ptr0 = arg1;
+  const len0 = arg2;
+  const result0 = new Uint8Array(memory0.buffer.slice(ptr0, ptr0 + len0 * 1));
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_2__/* .write */ .cW)(arg0 >>> 0, result0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant2 = ret;
+  switch (variant2.tag) {
+    case 'ok': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 0, true);
+      dataView(memory0).setBigInt64(arg3 + 8, toUint64(e), true);
+      break;
+    }
+    case 'err': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 1, true);
+      const { } = e;
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering12(arg0, arg1, arg2, arg3) {
+  const ptr0 = arg1;
+  const len0 = arg2;
+  const result0 = new Uint8Array(memory0.buffer.slice(ptr0, ptr0 + len0 * 1));
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_2__/* .blockingWrite */ .v_)(arg0 >>> 0, result0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant2 = ret;
+  switch (variant2.tag) {
+    case 'ok': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 0, true);
+      dataView(memory0).setBigInt64(arg3 + 8, toUint64(e), true);
+      break;
+    }
+    case 'err': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 1, true);
+      const { } = e;
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+let exports3;
+let realloc1;
+let postReturn0;
+const exports = {
+  generate(arg0, arg1) {
+    const ptr0 = realloc1(0, 0, 4, 48);
+    const val1 = arg0;
+    const len1 = val1.byteLength;
+    const ptr1 = realloc1(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(ptr0 + 4, len1, true);
+    dataView(memory0).setInt32(ptr0 + 0, ptr1, true);
+    const {name: v2_0, noTypescript: v2_1, instantiation: v2_2, map: v2_3, compat: v2_4, noNodejsCompat: v2_5, base64Cutoff: v2_6, tlaCompat: v2_7, validLiftingOptimization: v2_8 } = arg1;
+    const ptr3 = utf8Encode(v2_0, realloc1, memory0);
+    const len3 = utf8EncodedLen;
+    dataView(memory0).setInt32(ptr0 + 12, len3, true);
+    dataView(memory0).setInt32(ptr0 + 8, ptr3, true);
+    const variant4 = v2_1;
+    if (variant4 === null || variant4=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 16, 0, true);
+    } else {
+      const e = variant4;
+      dataView(memory0).setInt8(ptr0 + 16, 1, true);
+      dataView(memory0).setInt8(ptr0 + 17, e ? 1 : 0, true);
+    }
+    const variant5 = v2_2;
+    if (variant5 === null || variant5=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 18, 0, true);
+    } else {
+      const e = variant5;
+      dataView(memory0).setInt8(ptr0 + 18, 1, true);
+      dataView(memory0).setInt8(ptr0 + 19, e ? 1 : 0, true);
+    }
+    const variant10 = v2_3;
+    if (variant10 === null || variant10=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 20, 0, true);
+    } else {
+      const e = variant10;
+      dataView(memory0).setInt8(ptr0 + 20, 1, true);
+      const vec9 = e;
+      const len9 = vec9.length;
+      const result9 = realloc1(0, 0, 4, len9 * 16);
+      for (let i = 0; i < vec9.length; i++) {
+        const e = vec9[i];
+        const base = result9 + i * 16;const [tuple6_0, tuple6_1] = e;
+        const ptr7 = utf8Encode(tuple6_0, realloc1, memory0);
+        const len7 = utf8EncodedLen;
+        dataView(memory0).setInt32(base + 4, len7, true);
+        dataView(memory0).setInt32(base + 0, ptr7, true);
+        const ptr8 = utf8Encode(tuple6_1, realloc1, memory0);
+        const len8 = utf8EncodedLen;
+        dataView(memory0).setInt32(base + 12, len8, true);
+        dataView(memory0).setInt32(base + 8, ptr8, true);
+      }
+      dataView(memory0).setInt32(ptr0 + 28, len9, true);
+      dataView(memory0).setInt32(ptr0 + 24, result9, true);
+    }
+    const variant11 = v2_4;
+    if (variant11 === null || variant11=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 32, 0, true);
+    } else {
+      const e = variant11;
+      dataView(memory0).setInt8(ptr0 + 32, 1, true);
+      dataView(memory0).setInt8(ptr0 + 33, e ? 1 : 0, true);
+    }
+    const variant12 = v2_5;
+    if (variant12 === null || variant12=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 34, 0, true);
+    } else {
+      const e = variant12;
+      dataView(memory0).setInt8(ptr0 + 34, 1, true);
+      dataView(memory0).setInt8(ptr0 + 35, e ? 1 : 0, true);
+    }
+    const variant13 = v2_6;
+    if (variant13 === null || variant13=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 36, 0, true);
+    } else {
+      const e = variant13;
+      dataView(memory0).setInt8(ptr0 + 36, 1, true);
+      dataView(memory0).setInt32(ptr0 + 40, toUint32(e), true);
+    }
+    const variant14 = v2_7;
+    if (variant14 === null || variant14=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 44, 0, true);
+    } else {
+      const e = variant14;
+      dataView(memory0).setInt8(ptr0 + 44, 1, true);
+      dataView(memory0).setInt8(ptr0 + 45, e ? 1 : 0, true);
+    }
+    const variant15 = v2_8;
+    if (variant15 === null || variant15=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 46, 0, true);
+    } else {
+      const e = variant15;
+      dataView(memory0).setInt8(ptr0 + 46, 1, true);
+      dataView(memory0).setInt8(ptr0 + 47, e ? 1 : 0, true);
+    }
+    const ret = exports1['exports#generate'](ptr0);
+    let variant25;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        const len18 = dataView(memory0).getInt32(ret + 8, true);
+        const base18 = dataView(memory0).getInt32(ret + 4, true);
+        const result18 = [];
+        for (let i = 0; i < len18; i++) {
+          const base = base18 + i * 16;
+          const ptr16 = dataView(memory0).getInt32(base + 0, true);
+          const len16 = dataView(memory0).getInt32(base + 4, true);
+          const result16 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr16, len16));
+          const ptr17 = dataView(memory0).getInt32(base + 8, true);
+          const len17 = dataView(memory0).getInt32(base + 12, true);
+          const result17 = new Uint8Array(memory0.buffer.slice(ptr17, ptr17 + len17 * 1));
+          result18.push([result16, result17]);
+        }
+        const len20 = dataView(memory0).getInt32(ret + 16, true);
+        const base20 = dataView(memory0).getInt32(ret + 12, true);
+        const result20 = [];
+        for (let i = 0; i < len20; i++) {
+          const base = base20 + i * 8;
+          const ptr19 = dataView(memory0).getInt32(base + 0, true);
+          const len19 = dataView(memory0).getInt32(base + 4, true);
+          const result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
+          result20.push(result19);
+        }
+        const len23 = dataView(memory0).getInt32(ret + 24, true);
+        const base23 = dataView(memory0).getInt32(ret + 20, true);
+        const result23 = [];
+        for (let i = 0; i < len23; i++) {
+          const base = base23 + i * 12;
+          const ptr21 = dataView(memory0).getInt32(base + 0, true);
+          const len21 = dataView(memory0).getInt32(base + 4, true);
+          const result21 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr21, len21));
+          let enum22;
+          switch (dataView(memory0).getUint8(base + 8, true)) {
+            case 0: {
+              enum22 = 'function';
+              break;
+            }
+            case 1: {
+              enum22 = 'instance';
+              break;
+            }
+            default: {
+              throw new TypeError('invalid discriminant specified for ExportType');
+            }
+          }
+          result23.push([result21, enum22]);
+        }
+        variant25= {
+          tag: 'ok',
+          val: {
+            files: result18,
+            imports: result20,
+            exports: result23,
+          }
+        };
+        break;
+      }
+      case 1: {
+        const ptr24 = dataView(memory0).getInt32(ret + 4, true);
+        const len24 = dataView(memory0).getInt32(ret + 8, true);
+        const result24 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr24, len24));
+        variant25= {
+          tag: 'err',
+          val: result24
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    postReturn0(ret);
+    if (variant25.tag === 'err') {
+      throw new ComponentError(variant25.val);
+    }
+    return variant25.val;
+  },
+  
+};
+
+
+
+const $init = (async() => {
+  const module0 = fetchCompile(__nccwpck_require__.ab + "js-component-bindgen-component.core.wasm");
+  const module1 = fetchCompile(__nccwpck_require__.ab + "js-component-bindgen-component.core2.wasm");
+  const module2 = base64Compile('AGFzbQEAAAABKAdgAX8AYAJ/fwBgAn5/AGAEf39/fwBgBH9/f38Bf2ACf38Bf2ABfwADDQwAAAECAAMDBAUFBQYEBQFwAQwMBz4NATAAAAExAAEBMgACATMAAwE0AAQBNQAFATYABgE3AAcBOAAIATkACQIxMAAKAjExAAsIJGltcG9ydHMBAAqVAQwJACAAQQARAAALCQAgAEEBEQAACwsAIAAgAUECEQEACwsAIAAgAUEDEQIACwkAIABBBBEAAAsPACAAIAEgAiADQQURAwALDwAgACABIAIgA0EGEQMACw8AIAAgASACIANBBxEEAAsLACAAIAFBCBEFAAsLACAAIAFBCREFAAsLACAAIAFBChEFAAsJACAAQQsRBgALAC0JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQFMC44LjIAzwMEbmFtZQATEndpdC1jb21wb25lbnQ6c2hpbQGyAwwAG2luZGlyZWN0LXByZW9wZW5zLWdldC1zdGRpbwEhaW5kaXJlY3QtcHJlb3BlbnMtZ2V0LWRpcmVjdG9yaWVzAhxpbmRpcmVjdC1maWxlc3lzdGVtLWdldC10eXBlAyBpbmRpcmVjdC1yYW5kb20tZ2V0LXJhbmRvbS1ieXRlcwQkaW5kaXJlY3QtZW52aXJvbm1lbnQtZ2V0LWVudmlyb25tZW50BRZpbmRpcmVjdC1zdHJlYW1zLXdyaXRlBh9pbmRpcmVjdC1zdHJlYW1zLWJsb2NraW5nLXdyaXRlByVhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWZkX3dyaXRlCCdhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLXJhbmRvbV9nZXQJKGFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZW52aXJvbl9nZXQKLmFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtZW52aXJvbl9zaXplc19nZXQLJmFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtcHJvY19leGl0');
+  const module3 = base64Compile('AGFzbQEAAAABKAdgAX8AYAJ/fwBgAn5/AGAEf39/fwBgBH9/f38Bf2ACf38Bf2ABfwACTg0AATAAAAABMQAAAAEyAAEAATMAAgABNAAAAAE1AAMAATYAAwABNwAEAAE4AAUAATkABQACMTAABQACMTEABgAIJGltcG9ydHMBcAEMDAkSAQBBAAsMAAECAwQFBgcICQoLAC0JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQFMC44LjIAHARuYW1lABUUd2l0LWNvbXBvbmVudDpmaXh1cHM');
+  Promise.all([module0, module1, module2, module3]).catch(() => {});
+  ({ exports: exports0 } = await instantiateCore(await module2));
+  ({ exports: exports1 } = await instantiateCore(await module0, {
+    wasi_snapshot_preview1: {
+      environ_get: exports0['9'],
+      environ_sizes_get: exports0['10'],
+      fd_write: exports0['7'],
+      proc_exit: exports0['11'],
+      random_get: exports0['8'],
+    },
+  }));
+  ({ exports: exports2 } = await instantiateCore(await module1, {
+    __main_module__: {
+      cabi_realloc: exports1.cabi_realloc,
+    },
+    env: {
+      memory: exports1.memory,
+    },
+    environment: {
+      'get-environment': exports0['4'],
+    },
+    exit: {
+      exit: lowering3,
+    },
+    filesystem: {
+      'append-via-stream': lowering1,
+      'drop-descriptor': lowering2,
+      'get-type': exports0['2'],
+      'write-via-stream': lowering0,
+    },
+    preopens: {
+      'get-directories': exports0['1'],
+      'get-stdio': exports0['0'],
+    },
+    random: {
+      'get-random-bytes': exports0['3'],
+    },
+    streams: {
+      'blocking-write': exports0['6'],
+      'drop-input-stream': lowering4,
+      'drop-output-stream': lowering5,
+      write: exports0['5'],
+    },
+  }));
+  memory0 = exports1.memory;
+  realloc0 = exports2.cabi_import_realloc;
+  ({ exports: exports3 } = await instantiateCore(await module3, {
+    '': {
+      $imports: exports0.$imports,
+      '0': lowering6,
+      '1': lowering7,
+      '10': exports2.environ_sizes_get,
+      '11': exports2.proc_exit,
+      '2': lowering8,
+      '3': lowering9,
+      '4': lowering10,
+      '5': lowering11,
+      '6': lowering12,
+      '7': exports2.fd_write,
+      '8': exports2.random_get,
+      '9': exports2.environ_get,
+    },
+  }));
+  realloc1 = exports1.cabi_realloc;
+  postReturn0 = exports1['cabi_post_exports#generate'];
+})();
+
+await $init;
+
+__webpack_async_result__();
+} catch(e) { __webpack_async_result__(e); } }, 1);
+
+/***/ }),
+
+/***/ 8980:
+/***/ ((__webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+__nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   "I": () => (/* binding */ exports)
+/* harmony export */ });
+/* harmony import */ var _bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(5331);
+/* harmony import */ var _bytecodealliance_preview2_shim_exit__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(7393);
+/* harmony import */ var _bytecodealliance_preview2_shim_random__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(8576);
+/* harmony import */ var _bytecodealliance_preview2_shim_environment__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(9187);
+/* harmony import */ var _bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(9213);
+/* harmony import */ var _bytecodealliance_preview2_shim_preopens__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(833);
+
+
+
+
+
+
+
+const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
 
 class ComponentError extends Error {
   constructor (value) {
@@ -40375,10 +40803,8 @@ class ComponentError extends Error {
   }
 }
 
-function toString(val) {
-  if (typeof val === 'symbol') throw new TypeError('symbols cannot be converted to strings');
-  return String(val);
-}
+let dv = new DataView(new ArrayBuffer());
+const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
 
 const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
 let _fs;
@@ -40390,25 +40816,987 @@ async function fetchCompile (url) {
   return fetch(url).then(WebAssembly.compileStreaming);
 }
 
-const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
+function getErrorPayload(e) {
+  if (hasOwnProperty.call(e, 'payload')) return e.payload;
+  if (hasOwnProperty.call(e, 'message')) return String(e.message);
+  return String(e);
+}
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const instantiateCore = WebAssembly.instantiate;
+
+const toUint64 = val => BigInt.asUintN(64, val);
+
+function toString(val) {
+  if (typeof val === 'symbol') throw new TypeError('symbols cannot be converted to strings');
+  return String(val);
+}
+
+function toUint32(val) {
+  return val >>> 0;
+}
+
+const utf8Decoder = new TextDecoder();
+
+const utf8Encoder = new TextEncoder();
+
+let utf8EncodedLen = 0;
+function utf8Encode(s, realloc, memory) {
+  if (typeof s !== 'string') throw new TypeError('expected a string');
+  if (s.length === 0) {
+    utf8EncodedLen = 0;
+    return 1;
+  }
+  let allocLen = 0;
+  let ptr = 0;
+  let writtenTotal = 0;
+  while (s.length > 0) {
+    ptr = realloc(ptr, allocLen, 1, allocLen + s.length);
+    allocLen += s.length;
+    const { read, written } = utf8Encoder.encodeInto(
+    s,
+    new Uint8Array(memory.buffer, ptr + writtenTotal, allocLen - writtenTotal),
+    );
+    writtenTotal += written;
+    s = s.slice(read);
+  }
+  if (allocLen > writtenTotal)
+  ptr = realloc(ptr, allocLen, 1, writtenTotal);
+  utf8EncodedLen = writtenTotal;
+  return ptr;
+}
 
 let exports0;
 let exports1;
-let memory0;
 
-function lowering0(arg0, arg1) {
-  const ptr0 = arg0;
-  const len0 = arg1;
-  const result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-  (0,_lib_console_js__WEBPACK_IMPORTED_MODULE_0__/* .error */ .v)(result0);
+function lowering0(arg0) {
+  (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .dropDirectoryEntryStream */ .h1)(arg0 >>> 0);
+}
+
+function lowering1(arg0, arg1) {
+  const ret = (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .readViaStream */ .wF)(arg0 >>> 0, BigInt.asUintN(64, arg1));
+  return toUint32(ret);
+}
+
+function lowering2(arg0, arg1) {
+  const ret = (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .writeViaStream */ .Zw)(arg0 >>> 0, BigInt.asUintN(64, arg1));
+  return toUint32(ret);
+}
+
+function lowering3(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .appendViaStream */ .Tk)(arg0 >>> 0);
+  return toUint32(ret);
+}
+
+function lowering4(arg0) {
+  (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .dropDescriptor */ .Lk)(arg0 >>> 0);
+}
+
+function lowering5(arg0) {
+  let variant0;
+  switch (arg0) {
+    case 0: {
+      variant0= {
+        tag: 'ok',
+        val: undefined
+      };
+      break;
+    }
+    case 1: {
+      variant0= {
+        tag: 'err',
+        val: undefined
+      };
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant discriminant for expected');
+    }
+  }
+  (0,_bytecodealliance_preview2_shim_exit__WEBPACK_IMPORTED_MODULE_5__/* .exit */ .J)(variant0);
+}
+
+function lowering6(arg0) {
+  (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_3__/* .dropInputStream */ .dU)(arg0 >>> 0);
+}
+
+function lowering7(arg0) {
+  (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_3__/* .dropOutputStream */ .oc)(arg0 >>> 0);
 }
 let exports2;
+let memory0;
+
+function lowering8(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_preopens__WEBPACK_IMPORTED_MODULE_4__/* .getStdio */ .vT)();
+  const {stdin: v0_0, stdout: v0_1, stderr: v0_2 } = ret;
+  dataView(memory0).setInt32(arg0 + 0, toUint32(v0_0), true);
+  dataView(memory0).setInt32(arg0 + 4, toUint32(v0_1), true);
+  dataView(memory0).setInt32(arg0 + 8, toUint32(v0_2), true);
+}
 let realloc0;
+
+function lowering9(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_preopens__WEBPACK_IMPORTED_MODULE_4__/* .getDirectories */ .$z)();
+  const vec2 = ret;
+  const len2 = vec2.length;
+  const result2 = realloc0(0, 0, 4, len2 * 12);
+  for (let i = 0; i < vec2.length; i++) {
+    const e = vec2[i];
+    const base = result2 + i * 12;const [tuple0_0, tuple0_1] = e;
+    dataView(memory0).setInt32(base + 0, toUint32(tuple0_0), true);
+    const ptr1 = utf8Encode(tuple0_1, realloc0, memory0);
+    const len1 = utf8EncodedLen;
+    dataView(memory0).setInt32(base + 8, len1, true);
+    dataView(memory0).setInt32(base + 4, ptr1, true);
+  }
+  dataView(memory0).setInt32(arg0 + 4, len2, true);
+  dataView(memory0).setInt32(arg0 + 0, result2, true);
+}
+
+function lowering10(arg0, arg1) {
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .getType */ .oL)(arg0 >>> 0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant2 = ret;
+  switch (variant2.tag) {
+    case 'ok': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg1 + 0, 0, true);
+      const val0 = toString(e);
+      let enum0;
+      switch (val0) {
+        case 'unknown': {
+          enum0 = 0;
+          break;
+        }
+        case 'block-device': {
+          enum0 = 1;
+          break;
+        }
+        case 'character-device': {
+          enum0 = 2;
+          break;
+        }
+        case 'directory': {
+          enum0 = 3;
+          break;
+        }
+        case 'fifo': {
+          enum0 = 4;
+          break;
+        }
+        case 'symbolic-link': {
+          enum0 = 5;
+          break;
+        }
+        case 'regular-file': {
+          enum0 = 6;
+          break;
+        }
+        case 'socket': {
+          enum0 = 7;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val0}" is not one of the cases of descriptor-type`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 1, enum0, true);
+      break;
+    }
+    case 'err': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      const val1 = toString(e);
+      let enum1;
+      switch (val1) {
+        case 'access': {
+          enum1 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum1 = 1;
+          break;
+        }
+        case 'already': {
+          enum1 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum1 = 3;
+          break;
+        }
+        case 'busy': {
+          enum1 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum1 = 5;
+          break;
+        }
+        case 'quota': {
+          enum1 = 6;
+          break;
+        }
+        case 'exist': {
+          enum1 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum1 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum1 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum1 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum1 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum1 = 12;
+          break;
+        }
+        case 'io': {
+          enum1 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum1 = 14;
+          break;
+        }
+        case 'loop': {
+          enum1 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum1 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum1 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum1 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum1 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum1 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum1 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum1 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum1 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum1 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum1 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum1 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum1 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum1 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum1 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum1 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum1 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum1 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum1 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum1 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum1 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum1 = 36;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val1}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 1, enum1, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering11(arg0, arg1) {
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .stat */ .lz)(arg0 >>> 0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant6 = ret;
+  switch (variant6.tag) {
+    case 'ok': {
+      const e = variant6.val;
+      dataView(memory0).setInt8(arg1 + 0, 0, true);
+      const {device: v0_0, inode: v0_1, type: v0_2, linkCount: v0_3, size: v0_4, dataAccessTimestamp: v0_5, dataModificationTimestamp: v0_6, statusChangeTimestamp: v0_7 } = e;
+      dataView(memory0).setBigInt64(arg1 + 8, toUint64(v0_0), true);
+      dataView(memory0).setBigInt64(arg1 + 16, toUint64(v0_1), true);
+      const val1 = toString(v0_2);
+      let enum1;
+      switch (val1) {
+        case 'unknown': {
+          enum1 = 0;
+          break;
+        }
+        case 'block-device': {
+          enum1 = 1;
+          break;
+        }
+        case 'character-device': {
+          enum1 = 2;
+          break;
+        }
+        case 'directory': {
+          enum1 = 3;
+          break;
+        }
+        case 'fifo': {
+          enum1 = 4;
+          break;
+        }
+        case 'symbolic-link': {
+          enum1 = 5;
+          break;
+        }
+        case 'regular-file': {
+          enum1 = 6;
+          break;
+        }
+        case 'socket': {
+          enum1 = 7;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val1}" is not one of the cases of descriptor-type`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 24, enum1, true);
+      dataView(memory0).setBigInt64(arg1 + 32, toUint64(v0_3), true);
+      dataView(memory0).setBigInt64(arg1 + 40, toUint64(v0_4), true);
+      const {seconds: v2_0, nanoseconds: v2_1 } = v0_5;
+      dataView(memory0).setBigInt64(arg1 + 48, toUint64(v2_0), true);
+      dataView(memory0).setInt32(arg1 + 56, toUint32(v2_1), true);
+      const {seconds: v3_0, nanoseconds: v3_1 } = v0_6;
+      dataView(memory0).setBigInt64(arg1 + 64, toUint64(v3_0), true);
+      dataView(memory0).setInt32(arg1 + 72, toUint32(v3_1), true);
+      const {seconds: v4_0, nanoseconds: v4_1 } = v0_7;
+      dataView(memory0).setBigInt64(arg1 + 80, toUint64(v4_0), true);
+      dataView(memory0).setInt32(arg1 + 88, toUint32(v4_1), true);
+      break;
+    }
+    case 'err': {
+      const e = variant6.val;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      const val5 = toString(e);
+      let enum5;
+      switch (val5) {
+        case 'access': {
+          enum5 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum5 = 1;
+          break;
+        }
+        case 'already': {
+          enum5 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum5 = 3;
+          break;
+        }
+        case 'busy': {
+          enum5 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum5 = 5;
+          break;
+        }
+        case 'quota': {
+          enum5 = 6;
+          break;
+        }
+        case 'exist': {
+          enum5 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum5 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum5 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum5 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum5 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum5 = 12;
+          break;
+        }
+        case 'io': {
+          enum5 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum5 = 14;
+          break;
+        }
+        case 'loop': {
+          enum5 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum5 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum5 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum5 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum5 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum5 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum5 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum5 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum5 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum5 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum5 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum5 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum5 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum5 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum5 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum5 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum5 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum5 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum5 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum5 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum5 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum5 = 36;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val5}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 8, enum5, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering12(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+  if ((arg1 & 4294967294) !== 0) {
+    throw new TypeError('flags have extraneous bits set');
+  }
+  const flags0 = {
+    symlinkFollow: Boolean(arg1 & 1),
+  };
+  const ptr1 = arg2;
+  const len1 = arg3;
+  const result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+  if ((arg4 & 4294967280) !== 0) {
+    throw new TypeError('flags have extraneous bits set');
+  }
+  const flags2 = {
+    create: Boolean(arg4 & 1),
+    directory: Boolean(arg4 & 2),
+    exclusive: Boolean(arg4 & 4),
+    truncate: Boolean(arg4 & 8),
+  };
+  if ((arg5 & 4294967232) !== 0) {
+    throw new TypeError('flags have extraneous bits set');
+  }
+  const flags3 = {
+    read: Boolean(arg5 & 1),
+    write: Boolean(arg5 & 2),
+    fileIntegritySync: Boolean(arg5 & 4),
+    dataIntegritySync: Boolean(arg5 & 8),
+    requestedWriteSync: Boolean(arg5 & 16),
+    mutateDirectory: Boolean(arg5 & 32),
+  };
+  if ((arg6 & 4294967288) !== 0) {
+    throw new TypeError('flags have extraneous bits set');
+  }
+  const flags4 = {
+    readable: Boolean(arg6 & 1),
+    writeable: Boolean(arg6 & 2),
+    executable: Boolean(arg6 & 4),
+  };
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_filesystem__WEBPACK_IMPORTED_MODULE_0__/* .openAt */ .d2)(arg0 >>> 0, flags0, result1, flags2, flags3, flags4) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant6 = ret;
+  switch (variant6.tag) {
+    case 'ok': {
+      const e = variant6.val;
+      dataView(memory0).setInt8(arg7 + 0, 0, true);
+      dataView(memory0).setInt32(arg7 + 4, toUint32(e), true);
+      break;
+    }
+    case 'err': {
+      const e = variant6.val;
+      dataView(memory0).setInt8(arg7 + 0, 1, true);
+      const val5 = toString(e);
+      let enum5;
+      switch (val5) {
+        case 'access': {
+          enum5 = 0;
+          break;
+        }
+        case 'would-block': {
+          enum5 = 1;
+          break;
+        }
+        case 'already': {
+          enum5 = 2;
+          break;
+        }
+        case 'bad-descriptor': {
+          enum5 = 3;
+          break;
+        }
+        case 'busy': {
+          enum5 = 4;
+          break;
+        }
+        case 'deadlock': {
+          enum5 = 5;
+          break;
+        }
+        case 'quota': {
+          enum5 = 6;
+          break;
+        }
+        case 'exist': {
+          enum5 = 7;
+          break;
+        }
+        case 'file-too-large': {
+          enum5 = 8;
+          break;
+        }
+        case 'illegal-byte-sequence': {
+          enum5 = 9;
+          break;
+        }
+        case 'in-progress': {
+          enum5 = 10;
+          break;
+        }
+        case 'interrupted': {
+          enum5 = 11;
+          break;
+        }
+        case 'invalid': {
+          enum5 = 12;
+          break;
+        }
+        case 'io': {
+          enum5 = 13;
+          break;
+        }
+        case 'is-directory': {
+          enum5 = 14;
+          break;
+        }
+        case 'loop': {
+          enum5 = 15;
+          break;
+        }
+        case 'too-many-links': {
+          enum5 = 16;
+          break;
+        }
+        case 'message-size': {
+          enum5 = 17;
+          break;
+        }
+        case 'name-too-long': {
+          enum5 = 18;
+          break;
+        }
+        case 'no-device': {
+          enum5 = 19;
+          break;
+        }
+        case 'no-entry': {
+          enum5 = 20;
+          break;
+        }
+        case 'no-lock': {
+          enum5 = 21;
+          break;
+        }
+        case 'insufficient-memory': {
+          enum5 = 22;
+          break;
+        }
+        case 'insufficient-space': {
+          enum5 = 23;
+          break;
+        }
+        case 'not-directory': {
+          enum5 = 24;
+          break;
+        }
+        case 'not-empty': {
+          enum5 = 25;
+          break;
+        }
+        case 'not-recoverable': {
+          enum5 = 26;
+          break;
+        }
+        case 'unsupported': {
+          enum5 = 27;
+          break;
+        }
+        case 'no-tty': {
+          enum5 = 28;
+          break;
+        }
+        case 'no-such-device': {
+          enum5 = 29;
+          break;
+        }
+        case 'overflow': {
+          enum5 = 30;
+          break;
+        }
+        case 'not-permitted': {
+          enum5 = 31;
+          break;
+        }
+        case 'pipe': {
+          enum5 = 32;
+          break;
+        }
+        case 'read-only': {
+          enum5 = 33;
+          break;
+        }
+        case 'invalid-seek': {
+          enum5 = 34;
+          break;
+        }
+        case 'text-file-busy': {
+          enum5 = 35;
+          break;
+        }
+        case 'cross-device': {
+          enum5 = 36;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val5}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg7 + 4, enum5, true);
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering13(arg0, arg1) {
+  const ret = (0,_bytecodealliance_preview2_shim_random__WEBPACK_IMPORTED_MODULE_1__/* .getRandomBytes */ .Iv)(BigInt.asUintN(64, arg0));
+  const val0 = ret;
+  const len0 = val0.byteLength;
+  const ptr0 = realloc0(0, 0, 1, len0 * 1);
+  const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+  (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
+  dataView(memory0).setInt32(arg1 + 4, len0, true);
+  dataView(memory0).setInt32(arg1 + 0, ptr0, true);
+}
+
+function lowering14(arg0) {
+  const ret = (0,_bytecodealliance_preview2_shim_environment__WEBPACK_IMPORTED_MODULE_2__/* .getEnvironment */ .zj)();
+  const vec3 = ret;
+  const len3 = vec3.length;
+  const result3 = realloc0(0, 0, 4, len3 * 16);
+  for (let i = 0; i < vec3.length; i++) {
+    const e = vec3[i];
+    const base = result3 + i * 16;const [tuple0_0, tuple0_1] = e;
+    const ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
+    const len1 = utf8EncodedLen;
+    dataView(memory0).setInt32(base + 4, len1, true);
+    dataView(memory0).setInt32(base + 0, ptr1, true);
+    const ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+    const len2 = utf8EncodedLen;
+    dataView(memory0).setInt32(base + 12, len2, true);
+    dataView(memory0).setInt32(base + 8, ptr2, true);
+  }
+  dataView(memory0).setInt32(arg0 + 4, len3, true);
+  dataView(memory0).setInt32(arg0 + 0, result3, true);
+}
+
+function lowering15(arg0, arg1, arg2) {
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_3__/* .read */ .ij)(arg0 >>> 0, BigInt.asUintN(64, arg1)) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant3 = ret;
+  switch (variant3.tag) {
+    case 'ok': {
+      const e = variant3.val;
+      dataView(memory0).setInt8(arg2 + 0, 0, true);
+      const [tuple0_0, tuple0_1] = e;
+      const val1 = tuple0_0;
+      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);
+      dataView(memory0).setInt8(arg2 + 12, tuple0_1 ? 1 : 0, true);
+      break;
+    }
+    case 'err': {
+      const e = variant3.val;
+      dataView(memory0).setInt8(arg2 + 0, 1, true);
+      const { } = e;
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering16(arg0, arg1, arg2) {
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_3__/* .blockingRead */ .O_)(arg0 >>> 0, BigInt.asUintN(64, arg1)) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant3 = ret;
+  switch (variant3.tag) {
+    case 'ok': {
+      const e = variant3.val;
+      dataView(memory0).setInt8(arg2 + 0, 0, true);
+      const [tuple0_0, tuple0_1] = e;
+      const val1 = tuple0_0;
+      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);
+      dataView(memory0).setInt8(arg2 + 12, tuple0_1 ? 1 : 0, true);
+      break;
+    }
+    case 'err': {
+      const e = variant3.val;
+      dataView(memory0).setInt8(arg2 + 0, 1, true);
+      const { } = e;
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering17(arg0, arg1, arg2, arg3) {
+  const ptr0 = arg1;
+  const len0 = arg2;
+  const result0 = new Uint8Array(memory0.buffer.slice(ptr0, ptr0 + len0 * 1));
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_3__/* .write */ .cW)(arg0 >>> 0, result0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant2 = ret;
+  switch (variant2.tag) {
+    case 'ok': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 0, true);
+      dataView(memory0).setBigInt64(arg3 + 8, toUint64(e), true);
+      break;
+    }
+    case 'err': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 1, true);
+      const { } = e;
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+
+function lowering18(arg0, arg1, arg2, arg3) {
+  const ptr0 = arg1;
+  const len0 = arg2;
+  const result0 = new Uint8Array(memory0.buffer.slice(ptr0, ptr0 + len0 * 1));
+  let ret;
+  try {
+    ret = { tag: 'ok', val: (0,_bytecodealliance_preview2_shim_streams__WEBPACK_IMPORTED_MODULE_3__/* .blockingWrite */ .v_)(arg0 >>> 0, result0) };
+  } catch (e) {
+    ret = { tag: 'err', val: getErrorPayload(e) };
+  }
+  const variant2 = ret;
+  switch (variant2.tag) {
+    case 'ok': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 0, true);
+      dataView(memory0).setBigInt64(arg3 + 8, toUint64(e), true);
+      break;
+    }
+    case 'err': {
+      const e = variant2.val;
+      dataView(memory0).setInt8(arg3 + 0, 1, true);
+      const { } = e;
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant specified for result');
+    }
+  }
+}
+let exports3;
+let realloc1;
 let postReturn0;
 let postReturn1;
 const exports = {
   parse(arg0) {
-    const ptr0 = utf8Encode(arg0, realloc0, memory0);
+    const ptr0 = utf8Encode(arg0, realloc1, memory0);
     const len0 = utf8EncodedLen;
     const ret = exports1['exports#parse'](ptr0, len0);
     let variant3;
@@ -40446,7 +41834,7 @@ const exports = {
   print(arg0) {
     const val0 = arg0;
     const len0 = val0.byteLength;
-    const ptr0 = realloc0(0, 0, 1, len0 * 1);
+    const ptr0 = realloc1(0, 0, 1, len0 * 1);
     const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
     (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
     const ret = exports1['exports#print'](ptr0, len0);
@@ -40485,7 +41873,7 @@ const exports = {
   componentNew(arg0, arg1) {
     const val0 = arg0;
     const len0 = val0.byteLength;
-    const ptr0 = realloc0(0, 0, 1, len0 * 1);
+    const ptr0 = realloc1(0, 0, 1, len0 * 1);
     const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
     (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
     const variant5 = arg1;
@@ -40500,17 +41888,17 @@ const exports = {
       const e = variant5;
       const vec4 = e;
       const len4 = vec4.length;
-      const result4 = realloc0(0, 0, 4, len4 * 16);
+      const result4 = realloc1(0, 0, 4, len4 * 16);
       for (let i = 0; i < vec4.length; i++) {
         const e = vec4[i];
         const base = result4 + i * 16;const [tuple1_0, tuple1_1] = e;
-        const ptr2 = utf8Encode(tuple1_0, realloc0, memory0);
+        const ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
         const len2 = utf8EncodedLen;
         dataView(memory0).setInt32(base + 4, len2, true);
         dataView(memory0).setInt32(base + 0, ptr2, true);
         const val3 = tuple1_1;
         const len3 = val3.byteLength;
-        const ptr3 = realloc0(0, 0, 1, len3 * 1);
+        const ptr3 = realloc1(0, 0, 1, len3 * 1);
         const src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
         (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
         dataView(memory0).setInt32(base + 12, len3, true);
@@ -40556,7 +41944,7 @@ const exports = {
   componentWit(arg0, arg1) {
     const val0 = arg0;
     const len0 = val0.byteLength;
-    const ptr0 = realloc0(0, 0, 1, len0 * 1);
+    const ptr0 = realloc1(0, 0, 1, len0 * 1);
     const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
     (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
     const variant2 = arg1;
@@ -40569,7 +41957,7 @@ const exports = {
       variant2_2 = 0;
     } else {
       const e = variant2;
-      const ptr1 = utf8Encode(e, realloc0, memory0);
+      const ptr1 = utf8Encode(e, realloc1, memory0);
       const len1 = utf8EncodedLen;
       variant2_0 = 1;
       variant2_1 = ptr1;
@@ -40608,186 +41996,148 @@ const exports = {
     }
     return variant5.val;
   },
-  componentEmbed(arg0, arg1, arg2) {
-    const variant1 = arg0;
-    let variant1_0;
-    let variant1_1;
-    let variant1_2;
-    if (variant1 === null || variant1=== undefined) {
-      variant1_0 = 0;
-      variant1_1 = 0;
-      variant1_2 = 0;
+  componentEmbed(arg0) {
+    const ptr0 = realloc1(0, 0, 4, 64);
+    const {binary: v1_0, witSource: v1_1, witPath: v1_2, stringEncoding: v1_3, dummy: v1_4, world: v1_5, metadata: v1_6 } = arg0;
+    const variant3 = v1_0;
+    if (variant3 === null || variant3=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 0, 0, true);
     } else {
-      const e = variant1;
-      const val0 = e;
-      const len0 = val0.byteLength;
-      const ptr0 = realloc0(0, 0, 1, len0 * 1);
-      const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
-      (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
-      variant1_0 = 1;
-      variant1_1 = ptr0;
-      variant1_2 = len0;
-    }
-    const ptr2 = utf8Encode(arg1, realloc0, memory0);
-    const len2 = utf8EncodedLen;
-    const variant17 = arg2;
-    let variant17_0;
-    let variant17_1;
-    let variant17_2;
-    let variant17_3;
-    let variant17_4;
-    let variant17_5;
-    let variant17_6;
-    let variant17_7;
-    let variant17_8;
-    let variant17_9;
-    let variant17_10;
-    if (variant17 === null || variant17=== undefined) {
-      variant17_0 = 0;
-      variant17_1 = 0;
-      variant17_2 = 0;
-      variant17_3 = 0;
-      variant17_4 = 0;
-      variant17_5 = 0;
-      variant17_6 = 0;
-      variant17_7 = 0;
-      variant17_8 = 0;
-      variant17_9 = 0;
-      variant17_10 = 0;
+      const e = variant3;
+      dataView(memory0).setInt8(ptr0 + 0, 1, true);
+      const val2 = e;
+      const len2 = val2.byteLength;
+      const ptr2 = realloc1(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(ptr0 + 8, len2, true);
+      dataView(memory0).setInt32(ptr0 + 4, ptr2, true);
+    }
+    const variant5 = v1_1;
+    if (variant5 === null || variant5=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 12, 0, true);
     } else {
-      const e = variant17;
-      const {stringEncoding: v3_0, dummy: v3_1, world: v3_2, metadata: v3_3 } = e;
-      const variant5 = v3_0;
-      let variant5_0;
-      let variant5_1;
-      if (variant5 === null || variant5=== undefined) {
-        variant5_0 = 0;
-        variant5_1 = 0;
-      } else {
-        const e = variant5;
-        const val4 = toString(e);
-        let enum4;
-        switch (val4) {
-          case 'utf8': {
-            enum4 = 0;
-            break;
-          }
-          case 'utf16': {
-            enum4 = 1;
-            break;
-          }
-          case 'compact-utf16': {
-            enum4 = 2;
-            break;
-          }
-          default: {
-            throw new TypeError(`"${val4}" is not one of the cases of string-encoding`);
-          }
+      const e = variant5;
+      dataView(memory0).setInt8(ptr0 + 12, 1, true);
+      const ptr4 = utf8Encode(e, realloc1, memory0);
+      const len4 = utf8EncodedLen;
+      dataView(memory0).setInt32(ptr0 + 20, len4, true);
+      dataView(memory0).setInt32(ptr0 + 16, ptr4, true);
+    }
+    const variant7 = v1_2;
+    if (variant7 === null || variant7=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 24, 0, true);
+    } else {
+      const e = variant7;
+      dataView(memory0).setInt8(ptr0 + 24, 1, true);
+      const ptr6 = utf8Encode(e, realloc1, memory0);
+      const len6 = utf8EncodedLen;
+      dataView(memory0).setInt32(ptr0 + 32, len6, true);
+      dataView(memory0).setInt32(ptr0 + 28, ptr6, true);
+    }
+    const variant9 = v1_3;
+    if (variant9 === null || variant9=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 36, 0, true);
+    } else {
+      const e = variant9;
+      dataView(memory0).setInt8(ptr0 + 36, 1, true);
+      const val8 = toString(e);
+      let enum8;
+      switch (val8) {
+        case 'utf8': {
+          enum8 = 0;
+          break;
         }
-        variant5_0 = 1;
-        variant5_1 = enum4;
-      }
-      const variant6 = v3_1;
-      let variant6_0;
-      let variant6_1;
-      if (variant6 === null || variant6=== undefined) {
-        variant6_0 = 0;
-        variant6_1 = 0;
-      } else {
-        const e = variant6;
-        variant6_0 = 1;
-        variant6_1 = e ? 1 : 0;
-      }
-      const variant8 = v3_2;
-      let variant8_0;
-      let variant8_1;
-      let variant8_2;
-      if (variant8 === null || variant8=== undefined) {
-        variant8_0 = 0;
-        variant8_1 = 0;
-        variant8_2 = 0;
-      } else {
-        const e = variant8;
-        const ptr7 = utf8Encode(e, realloc0, memory0);
-        const len7 = utf8EncodedLen;
-        variant8_0 = 1;
-        variant8_1 = ptr7;
-        variant8_2 = len7;
-      }
-      const variant16 = v3_3;
-      let variant16_0;
-      let variant16_1;
-      let variant16_2;
-      if (variant16 === null || variant16=== undefined) {
-        variant16_0 = 0;
-        variant16_1 = 0;
-        variant16_2 = 0;
-      } else {
-        const e = variant16;
-        const vec15 = e;
-        const len15 = vec15.length;
-        const result15 = realloc0(0, 0, 4, len15 * 16);
-        for (let i = 0; i < vec15.length; i++) {
-          const e = vec15[i];
-          const base = result15 + i * 16;const [tuple9_0, tuple9_1] = e;
-          const ptr10 = utf8Encode(tuple9_0, realloc0, memory0);
-          const len10 = utf8EncodedLen;
-          dataView(memory0).setInt32(base + 4, len10, true);
-          dataView(memory0).setInt32(base + 0, ptr10, true);
-          const vec14 = tuple9_1;
-          const len14 = vec14.length;
-          const result14 = realloc0(0, 0, 4, len14 * 16);
-          for (let i = 0; i < vec14.length; i++) {
-            const e = vec14[i];
-            const base = result14 + i * 16;const [tuple11_0, tuple11_1] = e;
-            const ptr12 = utf8Encode(tuple11_0, realloc0, memory0);
-            const len12 = utf8EncodedLen;
-            dataView(memory0).setInt32(base + 4, len12, true);
-            dataView(memory0).setInt32(base + 0, ptr12, true);
-            const ptr13 = utf8Encode(tuple11_1, realloc0, memory0);
-            const len13 = utf8EncodedLen;
-            dataView(memory0).setInt32(base + 12, len13, true);
-            dataView(memory0).setInt32(base + 8, ptr13, true);
-          }
-          dataView(memory0).setInt32(base + 12, len14, true);
-          dataView(memory0).setInt32(base + 8, result14, true);
+        case 'utf16': {
+          enum8 = 1;
+          break;
+        }
+        case 'compact-utf16': {
+          enum8 = 2;
+          break;
+        }
+        default: {
+          throw new TypeError(`"${val8}" is not one of the cases of string-encoding`);
         }
-        variant16_0 = 1;
-        variant16_1 = result15;
-        variant16_2 = len15;
       }
-      variant17_0 = 1;
-      variant17_1 = variant5_0;
-      variant17_2 = variant5_1;
-      variant17_3 = variant6_0;
-      variant17_4 = variant6_1;
-      variant17_5 = variant8_0;
-      variant17_6 = variant8_1;
-      variant17_7 = variant8_2;
-      variant17_8 = variant16_0;
-      variant17_9 = variant16_1;
-      variant17_10 = variant16_2;
-    }
-    const ret = exports1['exports#component-embed'](variant1_0, variant1_1, variant1_2, ptr2, len2, variant17_0, variant17_1, variant17_2, variant17_3, variant17_4, variant17_5, variant17_6, variant17_7, variant17_8, variant17_9, variant17_10);
-    let variant20;
+      dataView(memory0).setInt8(ptr0 + 37, enum8, true);
+    }
+    const variant10 = v1_4;
+    if (variant10 === null || variant10=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 38, 0, true);
+    } else {
+      const e = variant10;
+      dataView(memory0).setInt8(ptr0 + 38, 1, true);
+      dataView(memory0).setInt8(ptr0 + 39, e ? 1 : 0, true);
+    }
+    const variant12 = v1_5;
+    if (variant12 === null || variant12=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 40, 0, true);
+    } else {
+      const e = variant12;
+      dataView(memory0).setInt8(ptr0 + 40, 1, true);
+      const ptr11 = utf8Encode(e, realloc1, memory0);
+      const len11 = utf8EncodedLen;
+      dataView(memory0).setInt32(ptr0 + 48, len11, true);
+      dataView(memory0).setInt32(ptr0 + 44, ptr11, true);
+    }
+    const variant20 = v1_6;
+    if (variant20 === null || variant20=== undefined) {
+      dataView(memory0).setInt8(ptr0 + 52, 0, true);
+    } else {
+      const e = variant20;
+      dataView(memory0).setInt8(ptr0 + 52, 1, true);
+      const vec19 = e;
+      const len19 = vec19.length;
+      const result19 = realloc1(0, 0, 4, len19 * 16);
+      for (let i = 0; i < vec19.length; i++) {
+        const e = vec19[i];
+        const base = result19 + i * 16;const [tuple13_0, tuple13_1] = e;
+        const ptr14 = utf8Encode(tuple13_0, realloc1, memory0);
+        const len14 = utf8EncodedLen;
+        dataView(memory0).setInt32(base + 4, len14, true);
+        dataView(memory0).setInt32(base + 0, ptr14, true);
+        const vec18 = tuple13_1;
+        const len18 = vec18.length;
+        const result18 = realloc1(0, 0, 4, len18 * 16);
+        for (let i = 0; i < vec18.length; i++) {
+          const e = vec18[i];
+          const base = result18 + i * 16;const [tuple15_0, tuple15_1] = e;
+          const ptr16 = utf8Encode(tuple15_0, realloc1, memory0);
+          const len16 = utf8EncodedLen;
+          dataView(memory0).setInt32(base + 4, len16, true);
+          dataView(memory0).setInt32(base + 0, ptr16, true);
+          const ptr17 = utf8Encode(tuple15_1, realloc1, memory0);
+          const len17 = utf8EncodedLen;
+          dataView(memory0).setInt32(base + 12, len17, true);
+          dataView(memory0).setInt32(base + 8, ptr17, true);
+        }
+        dataView(memory0).setInt32(base + 12, len18, true);
+        dataView(memory0).setInt32(base + 8, result18, true);
+      }
+      dataView(memory0).setInt32(ptr0 + 60, len19, true);
+      dataView(memory0).setInt32(ptr0 + 56, result19, true);
+    }
+    const ret = exports1['exports#component-embed'](ptr0);
+    let variant23;
     switch (dataView(memory0).getUint8(ret + 0, true)) {
       case 0: {
-        const ptr18 = dataView(memory0).getInt32(ret + 4, true);
-        const len18 = dataView(memory0).getInt32(ret + 8, true);
-        const result18 = new Uint8Array(memory0.buffer.slice(ptr18, ptr18 + len18 * 1));
-        variant20= {
+        const ptr21 = dataView(memory0).getInt32(ret + 4, true);
+        const len21 = dataView(memory0).getInt32(ret + 8, true);
+        const result21 = new Uint8Array(memory0.buffer.slice(ptr21, ptr21 + len21 * 1));
+        variant23= {
           tag: 'ok',
-          val: result18
+          val: result21
         };
         break;
       }
       case 1: {
-        const ptr19 = dataView(memory0).getInt32(ret + 4, true);
-        const len19 = dataView(memory0).getInt32(ret + 8, true);
-        const result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
-        variant20= {
+        const ptr22 = dataView(memory0).getInt32(ret + 4, true);
+        const len22 = dataView(memory0).getInt32(ret + 8, true);
+        const result22 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr22, len22));
+        variant23= {
           tag: 'err',
-          val: result19
+          val: result22
         };
         break;
       }
@@ -40796,15 +42146,15 @@ const exports = {
       }
     }
     postReturn0(ret);
-    if (variant20.tag === 'err') {
-      throw new ComponentError(variant20.val);
+    if (variant23.tag === 'err') {
+      throw new ComponentError(variant23.val);
     }
-    return variant20.val;
+    return variant23.val;
   },
   metadataShow(arg0) {
     const val0 = arg0;
     const len0 = val0.byteLength;
-    const ptr0 = realloc0(0, 0, 1, len0 * 1);
+    const ptr0 = realloc1(0, 0, 1, len0 * 1);
     const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
     (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
     const ret = exports1['exports#metadata-show'](ptr0, len0);
@@ -40911,30 +42261,30 @@ const exports = {
   metadataAdd(arg0, arg1) {
     const val0 = arg0;
     const len0 = val0.byteLength;
-    const ptr0 = realloc0(0, 0, 1, len0 * 1);
+    const ptr0 = realloc1(0, 0, 1, len0 * 1);
     const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
     (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
     const vec7 = arg1;
     const len7 = vec7.length;
-    const result7 = realloc0(0, 0, 4, len7 * 16);
+    const result7 = realloc1(0, 0, 4, len7 * 16);
     for (let i = 0; i < vec7.length; i++) {
       const e = vec7[i];
       const base = result7 + i * 16;const [tuple1_0, tuple1_1] = e;
-      const ptr2 = utf8Encode(tuple1_0, realloc0, memory0);
+      const ptr2 = utf8Encode(tuple1_0, realloc1, memory0);
       const len2 = utf8EncodedLen;
       dataView(memory0).setInt32(base + 4, len2, true);
       dataView(memory0).setInt32(base + 0, ptr2, true);
       const vec6 = tuple1_1;
       const len6 = vec6.length;
-      const result6 = realloc0(0, 0, 4, len6 * 16);
+      const result6 = realloc1(0, 0, 4, len6 * 16);
       for (let i = 0; i < vec6.length; i++) {
         const e = vec6[i];
         const base = result6 + i * 16;const [tuple3_0, tuple3_1] = e;
-        const ptr4 = utf8Encode(tuple3_0, realloc0, memory0);
+        const ptr4 = utf8Encode(tuple3_0, realloc1, memory0);
         const len4 = utf8EncodedLen;
         dataView(memory0).setInt32(base + 4, len4, true);
         dataView(memory0).setInt32(base + 0, ptr4, true);
-        const ptr5 = utf8Encode(tuple3_1, realloc0, memory0);
+        const ptr5 = utf8Encode(tuple3_1, realloc1, memory0);
         const len5 = utf8EncodedLen;
         dataView(memory0).setInt32(base + 12, len5, true);
         dataView(memory0).setInt32(base + 8, ptr5, true);
@@ -40982,23 +42332,95 @@ const exports = {
 
 const $init = (async() => {
   const module0 = fetchCompile(__nccwpck_require__.ab + "wasm-tools.core.wasm");
-  const module1 = base64Compile('AGFzbQEAAAABBgFgAn9/AAMCAQAEBQFwAQEBBxACATAAAAgkaW1wb3J0cwEACg0BCwAgACABQQARAAALAC0JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQFMC44LjEANQRuYW1lABMSd2l0LWNvbXBvbmVudDpzaGltARkBABZpbmRpcmVjdC1jb25zb2xlLWVycm9y');
-  const module2 = base64Compile('AGFzbQEAAAABBgFgAn9/AAIVAgABMAAAAAgkaW1wb3J0cwFwAQEBCQcBAEEACwEAAC0JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQFMC44LjEAHARuYW1lABUUd2l0LWNvbXBvbmVudDpmaXh1cHM=');
-  Promise.all([module0, module1, module2]).catch(() => {});
-  ({ exports: exports0 } = await instantiateCore(await module1));
+  const module1 = fetchCompile(__nccwpck_require__.ab + "wasm-tools.core2.wasm");
+  const module2 = base64Compile('AGFzbQEAAAABUgxgAX8AYAJ/fwBgCH9/f39/f39/AGACfn8AYAN/fn8AYAR/f39/AGACf38Bf2AEf39/fwF/YAl/f39/f35+f38Bf2ABfwF/YAN/f38Bf2ABfwADFxYAAAEBAgMABAQFBQYHBwgGBgYJBgoLBAUBcAEWFgdwFwEwAAABMQABATIAAgEzAAMBNAAEATUABQE2AAYBNwAHATgACAE5AAkCMTAACgIxMQALAjEyAAwCMTMADQIxNAAOAjE1AA8CMTYAEAIxNwARAjE4ABICMTkAEwIyMAAUAjIxABUIJGltcG9ydHMBAAqvAhYJACAAQQARAAALCQAgAEEBEQAACwsAIAAgAUECEQEACwsAIAAgAUEDEQEACxcAIAAgASACIAMgBCAFIAYgB0EEEQIACwsAIAAgAUEFEQMACwkAIABBBhEAAAsNACAAIAEgAkEHEQQACw0AIAAgASACQQgRBAALDwAgACABIAIgA0EJEQUACw8AIAAgASACIANBChEFAAsLACAAIAFBCxEGAAsPACAAIAEgAiADQQwRBwALDwAgACABIAIgA0ENEQcACxkAIAAgASACIAMgBCAFIAYgByAIQQ4RCAALCwAgACABQQ8RBgALCwAgACABQRARBgALCwAgACABQRERBgALCQAgAEESEQkACwsAIAAgAUETEQYACw0AIAAgASACQRQRCgALCQAgAEEVEQsACwAtCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BTAuOC4yAL8GBG5hbWUAExJ3aXQtY29tcG9uZW50OnNoaW0BogYWABtpbmRpcmVjdC1wcmVvcGVucy1nZXQtc3RkaW8BIWluZGlyZWN0LXByZW9wZW5zLWdldC1kaXJlY3RvcmllcwIcaW5kaXJlY3QtZmlsZXN5c3RlbS1nZXQtdHlwZQMYaW5kaXJlY3QtZmlsZXN5c3RlbS1zdGF0BBtpbmRpcmVjdC1maWxlc3lzdGVtLW9wZW4tYXQFIGluZGlyZWN0LXJhbmRvbS1nZXQtcmFuZG9tLWJ5dGVzBiRpbmRpcmVjdC1lbnZpcm9ubWVudC1nZXQtZW52aXJvbm1lbnQHFWluZGlyZWN0LXN0cmVhbXMtcmVhZAgeaW5kaXJlY3Qtc3RyZWFtcy1ibG9ja2luZy1yZWFkCRZpbmRpcmVjdC1zdHJlYW1zLXdyaXRlCh9pbmRpcmVjdC1zdHJlYW1zLWJsb2NraW5nLXdyaXRlCyxhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWZkX2ZpbGVzdGF0X2dldAwkYWRhcHQtd2FzaV9zbmFwc2hvdF9wcmV2aWV3MS1mZF9yZWFkDSVhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWZkX3dyaXRlDiZhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLXBhdGhfb3Blbg8nYWRhcHQtd2FzaV9zbmFwc2hvdF9wcmV2aWV3MS1yYW5kb21fZ2V0EChhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWVudmlyb25fZ2V0ES5hZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWVudmlyb25fc2l6ZXNfZ2V0EiVhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWZkX2Nsb3NlEythZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWZkX3ByZXN0YXRfZ2V0FDBhZGFwdC13YXNpX3NuYXBzaG90X3ByZXZpZXcxLWZkX3ByZXN0YXRfZGlyX25hbWUVJmFkYXB0LXdhc2lfc25hcHNob3RfcHJldmlldzEtcHJvY19leGl0');
+  const module3 = base64Compile('AGFzbQEAAAABUgxgAX8AYAJ/fwBgCH9/f39/f39/AGACfn8AYAN/fn8AYAR/f39/AGACf38Bf2AEf39/fwF/YAl/f39/f35+f38Bf2ABfwF/YAN/f38Bf2ABfwACigEXAAEwAAAAATEAAAABMgABAAEzAAEAATQAAgABNQADAAE2AAAAATcABAABOAAEAAE5AAUAAjEwAAUAAjExAAYAAjEyAAcAAjEzAAcAAjE0AAgAAjE1AAYAAjE2AAYAAjE3AAYAAjE4AAkAAjE5AAYAAjIwAAoAAjIxAAsACCRpbXBvcnRzAXABFhYJHAEAQQALFgABAgMEBQYHCAkKCwwNDg8QERITFBUALQlwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAUwLjguMgAcBG5hbWUAFRR3aXQtY29tcG9uZW50OmZpeHVwcw');
+  Promise.all([module0, module1, module2, module3]).catch(() => {});
+  ({ exports: exports0 } = await instantiateCore(await module2));
   ({ exports: exports1 } = await instantiateCore(await module0, {
-    console: {
-      error: exports0['0'],
+    wasi_snapshot_preview1: {
+      environ_get: exports0['16'],
+      environ_sizes_get: exports0['17'],
+      fd_close: exports0['18'],
+      fd_filestat_get: exports0['11'],
+      fd_prestat_dir_name: exports0['20'],
+      fd_prestat_get: exports0['19'],
+      fd_read: exports0['12'],
+      fd_write: exports0['13'],
+      path_open: exports0['14'],
+      proc_exit: exports0['21'],
+      random_get: exports0['15'],
+    },
+  }));
+  ({ exports: exports2 } = await instantiateCore(await module1, {
+    __main_module__: {
+      cabi_realloc: exports1.cabi_realloc,
+    },
+    env: {
+      memory: exports1.memory,
+    },
+    environment: {
+      'get-environment': exports0['6'],
+    },
+    exit: {
+      exit: lowering5,
+    },
+    filesystem: {
+      'append-via-stream': lowering3,
+      'drop-descriptor': lowering4,
+      'drop-directory-entry-stream': lowering0,
+      'get-type': exports0['2'],
+      'open-at': exports0['4'],
+      'read-via-stream': lowering1,
+      stat: exports0['3'],
+      'write-via-stream': lowering2,
+    },
+    preopens: {
+      'get-directories': exports0['1'],
+      'get-stdio': exports0['0'],
+    },
+    random: {
+      'get-random-bytes': exports0['5'],
+    },
+    streams: {
+      'blocking-read': exports0['8'],
+      'blocking-write': exports0['10'],
+      'drop-input-stream': lowering6,
+      'drop-output-stream': lowering7,
+      read: exports0['7'],
+      write: exports0['9'],
     },
   }));
   memory0 = exports1.memory;
-  ({ exports: exports2 } = await instantiateCore(await module2, {
+  realloc0 = exports2.cabi_import_realloc;
+  ({ exports: exports3 } = await instantiateCore(await module3, {
     '': {
       $imports: exports0.$imports,
-      '0': lowering0,
+      '0': lowering8,
+      '1': lowering9,
+      '10': lowering18,
+      '11': exports2.fd_filestat_get,
+      '12': exports2.fd_read,
+      '13': exports2.fd_write,
+      '14': exports2.path_open,
+      '15': exports2.random_get,
+      '16': exports2.environ_get,
+      '17': exports2.environ_sizes_get,
+      '18': exports2.fd_close,
+      '19': exports2.fd_prestat_get,
+      '2': lowering10,
+      '20': exports2.fd_prestat_dir_name,
+      '21': exports2.proc_exit,
+      '3': lowering11,
+      '4': lowering12,
+      '5': lowering13,
+      '6': lowering14,
+      '7': lowering15,
+      '8': lowering16,
+      '9': lowering17,
     },
   }));
-  realloc0 = exports1.cabi_realloc;
+  realloc1 = exports1.cabi_realloc;
   postReturn0 = exports1['cabi_post_exports#component-embed'];
   postReturn1 = exports1['cabi_post_exports#metadata-show'];
 })();
@@ -41008,6 +42430,611 @@ await $init;
 __webpack_async_result__();
 } catch(e) { __webpack_async_result__(e); } }, 1);
 
+/***/ }),
+
+/***/ 9187:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   "zj": () => (/* binding */ getEnvironment)
+/* harmony export */ });
+/* unused harmony exports _setEnv, preopens, getArguments */
+/* harmony import */ var node_process__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(7742);
+
+
+let _env;
+function _setEnv (envObj) {
+  _env = Object.entries(envObj);
+}
+
+function getEnvironment () {
+  if (!_env) _setEnv(node_process__WEBPACK_IMPORTED_MODULE_0__.env);
+  return _env;
+}
+
+function preopens () {
+  return [];
+}
+
+function getArguments () {
+  return [];
+}
+
+/***/ }),
+
+/***/ 7393:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   "J": () => (/* binding */ exit)
+/* harmony export */ });
+function exit(status) {
+  process.exit(status.tag === 'err' ? 1 : 0);
+}
+
+
+/***/ }),
+
+/***/ 5331:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   "Lk": () => (/* binding */ dropDescriptor),
+/* harmony export */   "Tk": () => (/* binding */ appendViaStream),
+/* harmony export */   "Zw": () => (/* binding */ writeViaStream),
+/* harmony export */   "d2": () => (/* binding */ openAt),
+/* harmony export */   "fm": () => (/* binding */ _convertFsError),
+/* harmony export */   "h1": () => (/* binding */ dropDirectoryEntryStream),
+/* harmony export */   "lz": () => (/* binding */ stat),
+/* harmony export */   "oL": () => (/* binding */ getType),
+/* harmony export */   "wF": () => (/* binding */ readViaStream)
+/* harmony export */ });
+/* unused harmony exports advise, syncData, getFlags, setFlags, setSize, setTimes, read, write, readDirectory, sync, createDirectoryAt, statAt, setTimesAt, linkAt, readlinkAt, removeDirectoryAt, renameAt, symlinkAt, unlinkFileAt, changeFilePermissionsAt, changeDirectoryPermissionsAt, lockShared, lockExclusive, tryLockShared, tryLockExclusive, unlock, readDirectoryEntry */
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(7561);
+/* harmony import */ var _preopens_js__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(833);
+/* harmony import */ var _streams_js__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(9213);
+
+
+
+
+function readViaStream(fd, offset) {
+  return (0,_streams_js__WEBPACK_IMPORTED_MODULE_2__/* ._createFileStream */ .HR)(fd, offset);
+}
+
+function writeViaStream(fd, offset) {
+  console.log(`[filesystem] WRITE STREAM ${fd} ${offset}`);
+}
+
+function appendViaStream(fd) {
+  console.log(`[filesystem] APPEND STREAM ${fd}`);
+}
+
+function advise(fd, offset, length, advice) {
+  console.log(`[filesystem] ADVISE`, fd, offset, length, advice);
+}
+
+function syncData(fd) {
+  console.log(`[filesystem] SYNC DATA ${fd}`);
+}
+
+function getFlags(fd) {
+  console.log(`[filesystem] FLAGS FOR ${fd}`);
+}
+
+function getType(fd) {
+  let type = (0,_preopens_js__WEBPACK_IMPORTED_MODULE_1__/* ._getDescriptorType */ .Am)(fd);
+  if (type === null) {
+    stat(fd);
+    type = (0,_preopens_js__WEBPACK_IMPORTED_MODULE_1__/* ._getDescriptorType */ .Am)(fd);
+  }
+  return type;
+}
+
+function setFlags(fd, flags) {
+  console.log(`[filesystem] SET FLAGS ${fd} ${JSON.stringify(flags)}`);
+}
+
+function setSize(fd, size) {
+  console.log(`[filesystem] SET SIZE`, fd, size);
+}
+
+function setTimes(fd, dataAccessTimestamp, dataModificationTimestamp) {
+  console.log(`[filesystem] SET TIMES`, fd, dataAccessTimestamp, dataModificationTimestamp);
+}
+
+function read(fd, length, offset) {
+  console.log(`[filesystem] READ`, fd, length, offset);
+}
+
+function write(fd, buffer, offset) {
+  console.log(`[filesystem] WRITE`, fd, buffer, offset);
+}
+
+let _dirStreams = [];
+function readDirectory(fd) {
+  const fullPath = _getFullPath(fd);
+  let dirs;
+  try {
+    dirs = readdirSync(fullPath, { withFileTypes: true });
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  _dirStreams.push({ fd, dirs, cursor: 0 });
+  return _dirStreams.length - 1;
+}
+
+function sync(fd) {
+  console.log(`[filesystem] SYNC`, fd);
+}
+
+function createDirectoryAt(fd, path) {
+  console.log(`[filesystem] CREATE DIRECTORY`, fd, path);
+}
+
+const nsMagnitude = 1_000_000_000_000n;
+function nsToDateTime (ns) {
+  const seconds = ns / nsMagnitude;
+  const nanoseconds = Number(ns % seconds);
+  return { seconds, nanoseconds };
+}
+
+function _convertFsError (e) {
+  switch (e.code) {
+    case 'EACCES': throw 'access';
+    case 'EAGAIN':
+    case 'EWOULDBLOCK': throw 'would-block';
+    case 'EALREADY': throw 'already';
+    case 'EBADF': throw 'bad-descriptor';
+    case 'EBUSY': throw 'busy';
+    case 'EDEADLK': throw 'deadlock';
+    case 'EDQUOT': throw 'quota';
+    case 'EEXIST': throw 'exist';
+    case 'EFBIG': throw 'file-too-large';
+    case 'EILSEQ': throw 'illegal-byte-sequence';
+    case 'EINPROGRESS': throw 'in-progress';
+    case 'EINTR': throw 'interrupted';
+    case 'EINVAL': throw 'invalid';
+    case 'EIO': throw 'io';
+    case 'EISDIR': throw 'is-directory';
+    case 'ELOOP': throw 'loop';
+    case 'EMLINK': throw 'too-many-links';
+    case 'EMSGSIZE': throw 'message-size';
+    case 'ENAMETOOLONG': throw 'name-too-long'
+    case 'ENODEV': throw 'no-device';
+    case 'ENOENT': throw 'no-entry';
+    case 'ENOLCK': throw 'no-lock';
+    case 'ENOMEM': throw 'insufficient-memory';
+    case 'ENOSPC': throw 'insufficient-space';
+    case 'ENOTDIR': throw 'not-directory';
+    case 'ENOTEMPTY': throw 'not-empty';
+    case 'ENOTRECOVERABLE': throw 'not-recoverable';
+    case 'ENOTSUP': throw 'unsupported';
+    case 'ENOTTY': throw 'no-tty';
+    case 'ENXIO': throw 'no-such-device';
+    case 'EOVERFLOW': throw 'overflow';
+    case 'EPERM': throw 'not-permitted';
+    case 'EPIPE': throw 'pipe';
+    case 'EROFS': throw 'read-only';
+    case 'ESPIPE': throw 'invalid-seek';
+    case 'ETXTBSY': throw 'text-file-busy';
+    case 'EXDEV': throw 'cross-device';
+    default: throw e;
+  }
+}
+
+function _lookupType (obj) {
+  if (obj.isFile())
+    return 'regular-file';
+  else if (obj.isSocket())
+    return 'socket';
+  else if (obj.isSymbolicLink())
+    return 'symbolic-link';
+  else if (obj.isFIFO())
+    return 'fifo';
+  else if (obj.isDirectory())
+    return 'directory';
+  else if (obj.isCharacterDevice())
+    return 'character-device';
+  else if (obj.isBlockDevice())
+    return 'block-device';
+  return 'unknown';
+}
+
+function stat(fd) {
+  let stats;
+  try {
+    stats = (0,node_fs__WEBPACK_IMPORTED_MODULE_0__.fstatSync)(fd, { bigint: true });
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  const type = _lookupType(stats);
+  (0,_preopens_js__WEBPACK_IMPORTED_MODULE_1__/* ._setDescriptorType */ .wM)(fd, type);
+  return {
+    device: stats.dev,
+    inode: stats.ino,
+    type,
+    linkCount: stats.nlink,
+    size: stats.size,
+    dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+    dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+    statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+  };
+}
+
+function statAt(fd, { symlinkFollow }, path) {
+  const fullPath = _descriptors[fd].path + path;
+  let stats;
+  try {
+    stats = (symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  const type = _lookupType(stats);
+  _setSubdescriptorType(fd, path, type);
+  return {
+    device: stats.dev,
+    inode: stats.ino,
+    type,
+    linkCount: stats.nlink,
+    size: stats.size,
+    dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+    dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+    statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+  };
+}
+
+function setTimesAt(fd) {
+  console.log(`[filesystem] SET TIMES AT`, fd);
+}
+
+function linkAt(fd) {
+  console.log(`[filesystem] LINK AT`, fd);
+}
+
+function openAt(fd, pathFlags, path, openFlags, descriptorFlags, modes) {
+  // TODO
+  // if (pathFlags.symlinkFollow) {
+  //   // resolve symlink
+  // }
+  const fullPath = _preopens_js__WEBPACK_IMPORTED_MODULE_1__/* ._descriptors */ .$B[fd].path + path;
+  let fsOpenFlags = 0x0;
+  if (openFlags.create)
+    fsOpenFlags |= node_fs__WEBPACK_IMPORTED_MODULE_0__.constants.O_CREAT;
+  if (openFlags.directory)
+    fsOpenFlags |= node_fs__WEBPACK_IMPORTED_MODULE_0__.constants.O_DIRECTORY;
+  if (openFlags.exclusive)
+    fsOpenFlags |= node_fs__WEBPACK_IMPORTED_MODULE_0__.constants.O_EXCL;
+  if (openFlags.truncate)
+    fsOpenFlags |= node_fs__WEBPACK_IMPORTED_MODULE_0__.constants.O_TRUNC;
+  if (descriptorFlags.read && descriptorFlags.write)
+    fsOpenFlags |= node_fs__WEBPACK_IMPORTED_MODULE_0__.constants.O_RDWR;
+  else if (descriptorFlags.write)
+    fsOpenFlags |= node_fs__WEBPACK_IMPORTED_MODULE_0__.constants.O_WRONLY;
+  // if (descriptorFlags.fileIntegritySync)
+  // if (descriptorFlags.dataIntegritySync)
+  // if (descriptorFlags.requestedWriteSync)
+  // if (descriptorFlags.mutateDirectory)
+  let fsMode = 0x0;
+  if (modes.readable)
+    fsMode |= 0o444;
+  if (modes.writeable)
+    fsMode |= 0o222;
+  if (modes.executable)
+    fsMode |= 0o111;
+  let localFd;
+  try {
+    localFd = (0,node_fs__WEBPACK_IMPORTED_MODULE_0__.openSync)(fullPath, fsOpenFlags, fsMode);
+  }
+  catch (e) {
+    _convertFsError(e);
+  }
+  (0,_preopens_js__WEBPACK_IMPORTED_MODULE_1__/* ._addOpenedDescriptor */ .jX)(localFd, path, fd);
+  return localFd;
+}
+
+function readlinkAt(fd) {
+  console.log(`[filesystem] READLINK AT`, fd);
+}
+
+function removeDirectoryAt(fd) {
+  console.log(`[filesystem] REMOVE DIR AT`, fd);
+}
+
+function renameAt(fd) {
+  console.log(`[filesystem] RENAME AT`, fd);
+}
+
+function symlinkAt(fd) {
+  console.log(`[filesystem] SYMLINK AT`, fd);
+}
+
+function unlinkFileAt(fd) {
+  console.log(`[filesystem] UNLINK FILE AT`, fd);
+}
+
+function changeFilePermissionsAt(fd) {
+  console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, fd);
+}
+
+function changeDirectoryPermissionsAt(fd) {
+  console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, fd);
+}
+
+function lockShared(fd) {
+  console.log(`[filesystem] LOCK SHARED`, fd);
+}
+
+function lockExclusive(fd) {
+  console.log(`[filesystem] LOCK EXCLUSIVE`, fd);
+}
+
+function tryLockShared(fd) {
+  console.log(`[filesystem] TRY LOCK SHARED`, fd);
+}
+
+function tryLockExclusive(fd) {
+  console.log(`[filesystem] TRY LOCK EXCLUSIVE`, fd);
+}
+
+function unlock(fd) {
+  console.log(`[filesystem] UNLOCK`, fd);
+}
+
+function dropDescriptor(fd) {
+  (0,_preopens_js__WEBPACK_IMPORTED_MODULE_1__/* ._removeOpenedDescriptor */ ._x)(fd);
+  (0,node_fs__WEBPACK_IMPORTED_MODULE_0__.closeSync)(fd);
+}
+
+function readDirectoryEntry(stream) {
+  const streamValue = _dirStreams[stream];
+  if (streamValue.cursor === streamValue.dirs.length)
+    return null;
+  const dir = streamValue.dirs[streamValue.cursor++];
+  const type = _lookupType(dir);
+  _setSubdescriptorType(streamValue.fd, '/' + dir.name, type);
+  return { inode: null, type, name: dir.name };
+}
+
+function dropDirectoryEntryStream(stream) {
+  _dirStreams.splice(stream, 1);
+}
+
+
+/***/ }),
+
+/***/ 833:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   "$B": () => (/* binding */ _descriptors),
+/* harmony export */   "$z": () => (/* binding */ getDirectories),
+/* harmony export */   "Am": () => (/* binding */ _getDescriptorType),
+/* harmony export */   "_x": () => (/* binding */ _removeOpenedDescriptor),
+/* harmony export */   "jX": () => (/* binding */ _addOpenedDescriptor),
+/* harmony export */   "vT": () => (/* binding */ getStdio),
+/* harmony export */   "wM": () => (/* binding */ _setDescriptorType)
+/* harmony export */ });
+/* unused harmony exports _getFullPath, _setSubdescriptorType, _setPreopens */
+// default is full permissions
+let preopenCnt = 4;
+let _descriptors = {
+  3: { type: 'directory', path: '/', parent: null, subpathTypes: {} }
+};
+let directories = [[3, '/']];
+
+function _getFullPath (fd) {
+  let path = '';
+  while (fd) {
+    path = _descriptors[fd].path + path;
+    fd = _descriptors[fd].parent;
+  }
+  return path;
+}
+
+function _getDescriptorType (fd) {
+  return _descriptors[fd].type;
+}
+
+function _setDescriptorType (fd, type) {
+  _descriptors[fd].type = type;
+}
+
+function _setSubdescriptorType (fd, path, type) {
+  while (_descriptors[fd].parent) {
+    path = _descriptors[fd].path + path;
+    fd = _descriptors[fd].parent;
+  }
+  _descriptors[fd].subpathTypes[path] = type;
+}
+
+function _addOpenedDescriptor (fd, path, parentFd) {
+  if (fd < preopenCnt || _descriptors[fd])
+    throw 'bad-descriptor';
+  let type = null;
+  for (const [_path, _type] of Object.entries(_descriptors[parentFd].subpathTypes)) {
+    if (_path === path)
+      type = _type;
+  }
+  _descriptors[fd] = { path, type, parent: parentFd, subpathTypes: {} };
+}
+
+function _removeOpenedDescriptor (fd) {
+  if (fd < preopenCnt)
+    throw 'eperm';
+  delete _descriptors[fd];
+}
+
+function _setPreopens (preopens) {
+  _descriptors = {};
+  directories = [,,];
+  for (const [virtualPath, path] of Object.entries(preopens)) {
+    _descriptors[preopenCnt] = { type: 'directory', path, parent: null, subpathTypes: {} };
+    directories.push([preopenCnt++, virtualPath]);
+  }
+}
+
+function getStdio () {
+  return {
+    stdin: 0,
+    stdout: 1,
+    stderr: 2,
+  };
+}
+
+function getDirectories () {
+  return directories;
+}
+
+
+/***/ }),
+
+/***/ 8576:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   "Iv": () => (/* binding */ getRandomBytes)
+/* harmony export */ });
+/* unused harmony exports getRandomU64, insecureRandom */
+/* harmony import */ var node_crypto__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(6005);
+
+
+function getRandomBytes(len) {
+  return (0,node_crypto__WEBPACK_IMPORTED_MODULE_0__.randomBytes)(Number(len));
+}
+
+function getRandomU64 () {
+  return new BigUint64Array(randomBytes(8).buffer)[0];
+}
+
+let insecureRandomValue1, insecureRandomValue2;
+function insecureRandom () {
+  if (insecureRandomValue1 === undefined) {
+    insecureRandomValue1 = getRandomU64();
+    insecureRandomValue2 = getRandomU64();
+  }
+  return [insecureRandomValue1, insecureRandomValue2];
+}
+
+
+/***/ }),
+
+/***/ 9213:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   "HR": () => (/* binding */ _createFileStream),
+/* harmony export */   "O_": () => (/* binding */ blockingRead),
+/* harmony export */   "cW": () => (/* binding */ write),
+/* harmony export */   "dU": () => (/* binding */ dropInputStream),
+/* harmony export */   "ij": () => (/* binding */ read),
+/* harmony export */   "oc": () => (/* binding */ dropOutputStream),
+/* harmony export */   "v_": () => (/* binding */ blockingWrite)
+/* harmony export */ });
+/* unused harmony exports _streams, skip, blockingSkip, subscribeToInputStream, writeZeroes, blockingWriteZeroes, splice, blockingSplice, forward, subscribeToOutputStream */
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(7561);
+/* harmony import */ var _filesystem_js__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(5331);
+
+
+
+let _streams = {};
+let streamCnt = 0;
+function _createFileStream(fd, offset) {
+  // note we only support offset 0
+  if (Number(offset) === 0)
+    _streams[streamCnt] = {
+      type: 'file',
+      fd: fd
+    };
+  return streamCnt++;
+}
+
+function read(s, len) {
+  switch (s) {
+    case 0:
+      return [process.stdin.read(len), true];
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
+}
+function blockingRead(s, len) {
+  len = Number(len);
+  const stream = _streams[s];
+  if (!stream) throw null;
+  switch (stream.type) {
+    case 'file': {
+      const buf = Buffer.alloc(Number(len));
+      try {
+        const readBytes = (0,node_fs__WEBPACK_IMPORTED_MODULE_0__.readSync)(stream.fd, buf, 0, Number(len));
+        if (readBytes < Number(len))
+          return [new Uint8Array(), true];
+        return [new Uint8Array(buf.buffer, 0, readBytes), false];
+      }
+      catch (e) {
+        (0,_filesystem_js__WEBPACK_IMPORTED_MODULE_1__/* ._convertFsError */ .fm)(e);
+      }
+      break;
+    }
+    default: throw null;
+  }
+}
+function skip(s, _len) {
+  console.log(`[streams] Skip ${s}`);
+}
+function blockingSkip(s, _len) {
+  console.log(`[streams] Blocking skip ${s}`);
+}
+function subscribeToInputStream(s) {
+  console.log(`[streams] Subscribe to input stream ${s}`);
+}
+function dropInputStream(s) {
+  delete _streams[s];
+
+}
+function write(s, buf) {
+  switch (s) {
+    case 0:
+      throw new Error(`TODO: write stdin`);
+    case 1: {
+      process.stdout.write(buf);
+      return BigInt(buf.byteLength);
+    }
+    case 2: {
+      process.stderr.write(buf);
+      return BigInt(buf.byteLength);
+    }
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
+}
+function blockingWrite(s, _buf) {
+  console.log(`[streams] Blocking write ${s}`);
+}
+function writeZeroes(s, _len) {
+  console.log(`[streams] Write zeroes ${s}`);
+}
+function blockingWriteZeroes(s, _len) {
+  console.log(`[streams] Blocking write zeroes ${s}`);
+}
+function splice(s, _src, _len) {
+  console.log(`[streams] Splice ${s}`);
+}
+function blockingSplice(s, _src, _len) {
+  console.log(`[streams] Blocking splice ${s}`);
+}
+function forward(s, _src) {
+  console.log(`[streams] Forward ${s}`);
+}
+function subscribeToOutputStream(s) {
+  console.log(`[streams] Subscribe to output stream ${s}`);
+}
+function dropOutputStream(s) {
+  console.log(`[streams] Drop output stream ${s}`);
+}
+
+
 /***/ }),
 
 /***/ 6772:
@@ -41037,10 +43064,10 @@ var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_cmd
 
 const { parse, print, componentNew, componentWit, componentEmbed, metadataAdd, metadataShow } = _obj_wasm_tools_js__WEBPACK_IMPORTED_MODULE_2__/* .exports */ .I;
 function preview1AdapterCommandPath () {
-  return __nccwpck_require__.ab + "wasi_snapshot_preview1.command.wasm";
+  return __nccwpck_require__.ab + "wasi_preview1_component_adapter.command.wasm";
 }
 function preview1AdapterReactorPath () {
-  return __nccwpck_require__.ab + "wasi_snapshot_preview1.reactor.wasm";
+  return __nccwpck_require__.ab + "wasi_preview1_component_adapter.reactor.wasm";
 }
 
 __webpack_async_result__();
@@ -41060,7 +43087,7 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(3292);
 /* harmony import */ var url__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(7310);
 /* harmony import */ var chalk_template__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(267);
-/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(8649);
+/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(7829);
 /* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(2719);
 var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_obj_wasm_tools_js__WEBPACK_IMPORTED_MODULE_0__]);
 _obj_wasm_tools_js__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
@@ -41233,7 +43260,7 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(3292);
 /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(1017);
 /* harmony import */ var chalk_template__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(267);
-/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(8649);
+/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(7829);
 /* harmony import */ var _opt_js__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(5862);
 /* harmony import */ var terser__WEBPACK_IMPORTED_MODULE_6__ = __nccwpck_require__(1124);
 /* harmony import */ var url__WEBPACK_IMPORTED_MODULE_7__ = __nccwpck_require__(7310);
@@ -41323,6 +43350,8 @@ async function wasm2Js (source) {
  * @returns {Promise<{ files: { [filename: string]: Uint8Array }, imports: string[], exports: [string, 'function' | 'instance'][] }>}
  */
 async function transpileComponent (component, opts = {}) {
+  if (opts.noWasiShim) opts.wasiShim = false;
+
   let spinner;
   const showSpinner = (0,_common_js__WEBPACK_IMPORTED_MODULE_4__/* .getShowSpinner */ .AZ)();
   if (opts.optimize) {
@@ -41330,19 +43359,37 @@ async function transpileComponent (component, opts = {}) {
     ({ component } = await (0,_opt_js__WEBPACK_IMPORTED_MODULE_5__/* .optimizeComponent */ .j)(component, opts));
   }
 
-  if (opts.wasiShim) {
+  if (opts.wasiShim !== false) {
     opts.map = Object.assign({
+      // Deprecated
       'environment-preopens': '@bytecodealliance/preview2-shim/environment-preopens',
+      'console': '@bytecodealliance/preview2-shim/console',
+      'default-outgoing-HTTP': '@bytecodealliance/preview2-shim/default-outgoing-HTTP',
       'environment': '@bytecodealliance/preview2-shim/environment',
+      // Deprecated
+      'environment-preopens': '@bytecodealliance/preview2-shim/environment-preopens',
       'exit': '@bytecodealliance/preview2-shim/exit',
       'filesystem': '@bytecodealliance/preview2-shim/filesystem',
+      // Deprecated
       'instance-monotonic-clock': '@bytecodealliance/preview2-shim/instance-monotonic-clock',
+      // Deprecated
       'instance-wall-clock': '@bytecodealliance/preview2-shim/instance-wall-clock',
+      'instance-network': '@bytecodealliance/preview2-shim/instance-network',
+      'ip-name-lookup': '@bytecodealliance/preview2-shim/ip-name-lookup',
       'monotonic-clock': '@bytecodealliance/preview2-shim/monotonic-clock',
+      'network': '@bytecodealliance/preview2-shim/network',
+      'poll': '@bytecodealliance/preview2-shim/poll',
       'preopens': '@bytecodealliance/preview2-shim/preopens',
       'random': '@bytecodealliance/preview2-shim/random',
+      // Deprecated
       'stderr': '@bytecodealliance/preview2-shim/stderr',
       'streams': '@bytecodealliance/preview2-shim/streams',
+      'tcp-create-socket': '@bytecodealliance/preview2-shim/tcp-create-socket',
+      'tcp': '@bytecodealliance/preview2-shim/tcp',
+      'timezone': '@bytecodealliance/preview2-shim/timezone',
+      'types': '@bytecodealliance/preview2-shim/types',
+      'udp-create-socket': '@bytecodealliance/preview2-shim/udp-create-socket',
+      'udp': '@bytecodealliance/preview2-shim/udp',
       'wall-clock': '@bytecodealliance/preview2-shim/wall-clock'
     }, opts.map || {});
   }
@@ -41623,7 +43670,7 @@ __webpack_async_result__();
 
 /***/ }),
 
-/***/ 8649:
+/***/ 7829:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
 
 
@@ -41636,8 +43683,8 @@ __nccwpck_require__.d(__webpack_exports__, {
 
 // UNUSED EXPORTS: fixedDigitDisplay, getTmpFile, readFile, sizeStr, table
 
-;// CONCATENATED MODULE: external "node:crypto"
-const external_node_crypto_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:crypto");
+// EXTERNAL MODULE: external "node:crypto"
+var external_node_crypto_ = __nccwpck_require__(6005);
 ;// CONCATENATED MODULE: external "node:path"
 const external_node_path_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:path");
 // EXTERNAL MODULE: external "node:os"
@@ -41710,7 +43757,7 @@ function table (data, align = []) {
 }
 
 function getTmpFile (source, ext) {
-  return (0,external_node_path_namespaceObject.resolve)((0,external_node_os_.tmpdir)(), external_node_crypto_namespaceObject.createHash('sha256').update(source).update(Math.random().toString()).digest('hex') + ext);
+  return (0,external_node_path_namespaceObject.resolve)((0,external_node_os_.tmpdir)(), external_node_crypto_.createHash('sha256').update(source).update(Math.random().toString()).digest('hex') + ext);
 }
 
 async function readFileCli (file, encoding) {