@netlify/edge-bundler 8.8.0 → 8.8.1

package/deno/vendor/deno.land/x/{eszip@v0.28.0 → eszip@v0.37.0}/eszip_wasm.generated.js

@@ -1,7 +1,7 @@
 // @generated file from wasmbuild -- do not edit
 // deno-lint-ignore-file
 // deno-fmt-ignore-file
-// source-hash: 0e24dd809865bd2b3c39b005f133376180af8ad2
+// source-hash: 89edd81d716c7387c15968a0de6fbb8736997e92
 let wasm;
 
 const heap = new Array(32).fill(undefined);
@@ -12,9 +12,32 @@ function getObject(idx) {
   return heap[idx];
 }
 
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
+
+let cachedFloat64Memory0 = new Float64Array();
+
+function getFloat64Memory0() {
+  if (cachedFloat64Memory0.byteLength === 0) {
+    cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
+  }
+  return cachedFloat64Memory0;
+}
+
+let cachedInt32Memory0 = new Int32Array();
+
+function getInt32Memory0() {
+  if (cachedInt32Memory0.byteLength === 0) {
+    cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+  }
+  return cachedInt32Memory0;
+}
+
 let WASM_VECTOR_LEN = 0;
 
-let cachedUint8Memory0;
+let cachedUint8Memory0 = new Uint8Array();
+
 function getUint8Memory0() {
   if (cachedUint8Memory0.byteLength === 0) {
     cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
@@ -65,19 +88,27 @@ function passStringToWasm0(arg, malloc, realloc) {
   return ptr;
 }
 
-function isLikeNone(x) {
-  return x === undefined || x === null;
-}
+let heap_next = heap.length;
 
-let cachedInt32Memory0;
-function getInt32Memory0() {
-  if (cachedInt32Memory0.byteLength === 0) {
-    cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
-  }
-  return cachedInt32Memory0;
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  const idx = heap_next;
+  heap_next = heap[idx];
+
+  heap[idx] = obj;
+  return idx;
 }
 
-let heap_next = heap.length;
+const cachedTextDecoder = new TextDecoder("utf-8", {
+  ignoreBOM: true,
+  fatal: true,
+});
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
 
 function dropObject(idx) {
   if (idx < 36) return;
@@ -91,24 +122,78 @@ function takeObject(idx) {
   return ret;
 }
 
-const cachedTextDecoder = new TextDecoder("utf-8", {
-  ignoreBOM: true,
-  fatal: true,
-});
-
-cachedTextDecoder.decode();
+let cachedBigInt64Memory0 = new BigInt64Array();
 
-function getStringFromWasm0(ptr, len) {
-  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+function getBigInt64Memory0() {
+  if (cachedBigInt64Memory0.byteLength === 0) {
+    cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
+  }
+  return cachedBigInt64Memory0;
 }
 
-function addHeapObject(obj) {
-  if (heap_next === heap.length) heap.push(heap.length + 1);
-  const idx = heap_next;
-  heap_next = heap[idx];
-
-  heap[idx] = obj;
-  return idx;
+function debugString(val) {
+  // primitive types
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  // objects
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  // Test for built-in
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    // Failed to match the standard '[object ClassName]'
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    // we're a user defined class or Object
+    // JSON.stringify avoids problems with cycles, and is generally much
+    // easier than looping through ownProperties of `val`.
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  // errors
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}\n${val.stack}`;
+  }
+  // TODO we could test for more things here, like `Set`s and `Map`s.
+  return className;
 }
 
 const CLOSURE_DTORS = new FinalizationRegistry((state) => {
@@ -139,9 +224,9 @@ function makeMutClosure(arg0, arg1, dtor, f) {
   CLOSURE_DTORS.register(real, state, state);
   return real;
 }
-function __wbg_adapter_18(arg0, arg1, arg2) {
+function __wbg_adapter_40(arg0, arg1, arg2) {
   wasm
-    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd4f05ebc54a3a357(
+    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hdb89611f6af59487(
       arg0,
       arg1,
       addHeapObject(arg2),
@@ -177,8 +262,8 @@ function handleError(f, args) {
     wasm.__wbindgen_exn_store(addHeapObject(e));
   }
 }
-function __wbg_adapter_50(arg0, arg1, arg2, arg3) {
-  wasm.wasm_bindgen__convert__closures__invoke2_mut__hccb8632b1071bfde(
+function __wbg_adapter_98(arg0, arg1, arg2, arg3) {
+  wasm.wasm_bindgen__convert__closures__invoke2_mut__h73ff6ec860ceda5d(
     arg0,
     arg1,
     addHeapObject(arg2),
@@ -276,6 +361,21 @@ export class Parser {
 
 const imports = {
   __wbindgen_placeholder__: {
+    __wbindgen_in: function (arg0, arg1) {
+      const ret = getObject(arg0) in getObject(arg1);
+      return ret;
+    },
+    __wbindgen_number_get: function (arg0, arg1) {
+      const obj = getObject(arg1);
+      const ret = typeof (obj) === "number" ? obj : undefined;
+      getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
+      getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    },
+    __wbindgen_boolean_get: function (arg0) {
+      const v = getObject(arg0);
+      const ret = typeof (v) === "boolean" ? (v ? 1 : 0) : 2;
+      return ret;
+    },
     __wbindgen_string_get: function (arg0, arg1) {
       const obj = getObject(arg1);
       const ret = typeof (obj) === "string" ? obj : undefined;
@@ -290,26 +390,40 @@ const imports = {
       getInt32Memory0()[arg0 / 4 + 1] = len0;
       getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     },
-    __wbindgen_object_drop_ref: function (arg0) {
-      takeObject(arg0);
+    __wbindgen_is_bigint: function (arg0) {
+      const ret = typeof (getObject(arg0)) === "bigint";
+      return ret;
+    },
+    __wbindgen_is_object: function (arg0) {
+      const val = getObject(arg0);
+      const ret = typeof (val) === "object" && val !== null;
+      return ret;
+    },
+    __wbindgen_bigint_from_i64: function (arg0) {
+      const ret = arg0;
+      return addHeapObject(ret);
+    },
+    __wbindgen_bigint_from_u64: function (arg0) {
+      const ret = BigInt.asUintN(64, arg0);
+      return addHeapObject(ret);
+    },
+    __wbg_new_1d9a920c6bfc44a8: function () {
+      const ret = new Array();
+      return addHeapObject(ret);
     },
     __wbindgen_string_new: function (arg0, arg1) {
       const ret = getStringFromWasm0(arg0, arg1);
       return addHeapObject(ret);
     },
-    __wbindgen_json_serialize: function (arg0, arg1) {
-      const obj = getObject(arg1);
-      const ret = JSON.stringify(obj === undefined ? null : obj);
-      const ptr0 = passStringToWasm0(
-        ret,
-        wasm.__wbindgen_malloc,
-        wasm.__wbindgen_realloc,
-      );
-      const len0 = WASM_VECTOR_LEN;
-      getInt32Memory0()[arg0 / 4 + 1] = len0;
-      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    __wbg_push_740e4b286702d964: function (arg0, arg1) {
+      const ret = getObject(arg0).push(getObject(arg1));
+      return ret;
     },
-    __wbg_new_651776e932b7e9c7: function (arg0, arg1) {
+    __wbg_length_6e3bbe7c8bd4dbd8: function (arg0) {
+      const ret = getObject(arg0).length;
+      return ret;
+    },
+    __wbg_new_8d2af00bc1e329ee: function (arg0, arg1) {
       const ret = new Error(getStringFromWasm0(arg0, arg1));
       return addHeapObject(ret);
     },
@@ -317,11 +431,11 @@ const imports = {
       const ret = wasm.memory;
       return addHeapObject(ret);
     },
-    __wbg_buffer_de1150f91b23aa89: function (arg0) {
+    __wbg_buffer_3f3d764d4747d564: function (arg0) {
       const ret = getObject(arg0).buffer;
       return addHeapObject(ret);
     },
-    __wbg_newwithbyteoffsetandlength_9ca61320599a2c84: function (
+    __wbg_newwithbyteoffsetandlength_d9aa266703cb98be: function (
       arg0,
       arg1,
       arg2,
@@ -329,59 +443,62 @@ const imports = {
       const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
       return addHeapObject(ret);
     },
-    __wbg_new_97cf52648830a70d: function (arg0) {
+    __wbg_new_8c3f0052272a457a: function (arg0) {
       const ret = new Uint8Array(getObject(arg0));
       return addHeapObject(ret);
     },
-    __wbg_new_2ab697f1555e0dbc: function () {
-      const ret = new Array();
-      return addHeapObject(ret);
+    __wbg_String_91fba7ded13ba54c: function (arg0, arg1) {
+      const ret = String(getObject(arg1));
+      const ptr0 = passStringToWasm0(
+        ret,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
+      const len0 = WASM_VECTOR_LEN;
+      getInt32Memory0()[arg0 / 4 + 1] = len0;
+      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     },
-    __wbg_push_811c8b08bf4ff9d5: function (arg0, arg1) {
-      const ret = getObject(arg0).push(getObject(arg1));
+    __wbindgen_jsval_eq: function (arg0, arg1) {
+      const ret = getObject(arg0) === getObject(arg1);
       return ret;
     },
-    __wbg_resolve_f269ce174f88b294: function (arg0) {
-      const ret = Promise.resolve(getObject(arg0));
+    __wbindgen_error_new: function (arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    },
+    __wbg_iterator_6f9d4f28845f426c: function () {
+      const ret = Symbol.iterator;
       return addHeapObject(ret);
     },
-    __wbg_newwithlength_e833b89f9db02732: function (arg0) {
+    __wbg_newwithlength_f5933855e4f48a19: function (arg0) {
       const ret = new Uint8Array(arg0 >>> 0);
       return addHeapObject(ret);
     },
-    __wbg_read_33fc0c1143d99231: function (arg0, arg1) {
+    __wbg_read_1bddf8e8af59d1d6: function (arg0, arg1) {
       const ret = getObject(arg0).read(getObject(arg1));
       return addHeapObject(ret);
     },
-    __wbg_done_9d9636ea8e221033: function (arg0) {
+    __wbg_done_1c9555f2eaa593e9: function (arg0) {
       const ret = getObject(arg0).done;
       return ret;
     },
-    __wbindgen_is_object: function (arg0) {
-      const val = getObject(arg0);
-      const ret = typeof (val) === "object" && val !== null;
-      return ret;
-    },
-    __wbg_toString_81e19471abb6dc98: function (arg0) {
+    __wbg_toString_7be108a12ef03bc2: function (arg0) {
       const ret = getObject(arg0).toString();
       return addHeapObject(ret);
     },
-    __wbg_value_57cc9a30b585d121: function (arg0) {
+    __wbg_value_a5e55ed0660d29ac: function (arg0) {
       const ret = getObject(arg0).value;
       return isLikeNone(ret) ? 0 : addHeapObject(ret);
     },
-    __wbg_byteLength_cf73ca7a0d44cb85: function (arg0) {
+    __wbg_byteLength_87a0436a74adc26c: function (arg0) {
       const ret = getObject(arg0).byteLength;
       return ret;
     },
-    __wbg_length_e09c0b925ab8de5d: function (arg0) {
+    __wbg_length_9e1ae1900cb0fbd5: function (arg0) {
       const ret = getObject(arg0).length;
       return ret;
     },
-    __wbg_set_a0172b213e2469e9: function (arg0, arg1, arg2) {
-      getObject(arg0).set(getObject(arg1), arg2 >>> 0);
-    },
-    __wbg_call_8e1338b908441bd2: function () {
+    __wbg_call_3999bee59e9f7719: function () {
       return handleError(function (arg0, arg1, arg2, arg3) {
         const ret = getObject(arg0).call(
           getObject(arg1),
@@ -391,14 +508,18 @@ const imports = {
         return addHeapObject(ret);
       }, arguments);
     },
-    __wbg_new_78403b138428b684: function (arg0, arg1) {
+    __wbg_resolve_99fe17964f31ffc0: function (arg0) {
+      const ret = Promise.resolve(getObject(arg0));
+      return addHeapObject(ret);
+    },
+    __wbg_new_9962f939219f1820: function (arg0, arg1) {
       try {
         var state0 = { a: arg0, b: arg1 };
         var cb0 = (arg0, arg1) => {
           const a = state0.a;
           state0.a = 0;
           try {
-            return __wbg_adapter_50(a, state0.b, arg0, arg1);
+            return __wbg_adapter_98(a, state0.b, arg0, arg1);
           } finally {
             state0.a = a;
           }
@@ -409,11 +530,11 @@ const imports = {
         state0.a = state0.b = 0;
       }
     },
-    __wbg_new_693216e109162396: function () {
+    __wbg_new_abda76e883ba8a5f: function () {
       const ret = new Error();
       return addHeapObject(ret);
     },
-    __wbg_stack_0ddaca5d1abfb52f: function (arg0, arg1) {
+    __wbg_stack_658279fe44541cf6: function (arg0, arg1) {
       const ret = getObject(arg1).stack;
       const ptr0 = passStringToWasm0(
         ret,
@@ -424,19 +545,116 @@ const imports = {
       getInt32Memory0()[arg0 / 4 + 1] = len0;
       getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     },
-    __wbg_error_09919627ac0992f5: function (arg0, arg1) {
+    __wbg_error_f851667af71bcfc6: function (arg0, arg1) {
       try {
         console.error(getStringFromWasm0(arg0, arg1));
       } finally {
         wasm.__wbindgen_free(arg0, arg1);
       }
     },
-    __wbg_call_9855a4612eb496cb: function () {
+    __wbindgen_object_drop_ref: function (arg0) {
+      takeObject(arg0);
+    },
+    __wbindgen_is_function: function (arg0) {
+      const ret = typeof (getObject(arg0)) === "function";
+      return ret;
+    },
+    __wbg_get_57245cc7d7c7619d: function (arg0, arg1) {
+      const ret = getObject(arg0)[arg1 >>> 0];
+      return addHeapObject(ret);
+    },
+    __wbg_next_aaef7c8aa5e212ac: function () {
+      return handleError(function (arg0) {
+        const ret = getObject(arg0).next();
+        return addHeapObject(ret);
+      }, arguments);
+    },
+    __wbg_done_1b73b0672e15f234: function (arg0) {
+      const ret = getObject(arg0).done;
+      return ret;
+    },
+    __wbg_value_1ccc36bc03462d71: function (arg0) {
+      const ret = getObject(arg0).value;
+      return addHeapObject(ret);
+    },
+    __wbg_get_765201544a2b6869: function () {
+      return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    },
+    __wbg_call_97ae9d8645dc388b: function () {
+      return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    },
+    __wbg_next_579e583d33566a86: function (arg0) {
+      const ret = getObject(arg0).next;
+      return addHeapObject(ret);
+    },
+    __wbg_isArray_27c46c67f498e15d: function (arg0) {
+      const ret = Array.isArray(getObject(arg0));
+      return ret;
+    },
+    __wbg_call_168da88779e35f61: function () {
       return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
       }, arguments);
     },
+    __wbg_isSafeInteger_dfa0593e8d7ac35a: function (arg0) {
+      const ret = Number.isSafeInteger(getObject(arg0));
+      return ret;
+    },
+    __wbg_set_83db9690f9353e79: function (arg0, arg1, arg2) {
+      getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+    },
+    __wbindgen_jsval_loose_eq: function (arg0, arg1) {
+      const ret = getObject(arg0) == getObject(arg1);
+      return ret;
+    },
+    __wbg_instanceof_Uint8Array_971eeda69eb75003: function (arg0) {
+      let result;
+      try {
+        result = getObject(arg0) instanceof Uint8Array;
+      } catch {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_ArrayBuffer_e5e48f4762c5610b: function (arg0) {
+      let result;
+      try {
+        result = getObject(arg0) instanceof ArrayBuffer;
+      } catch {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_entries_65a76a413fc91037: function (arg0) {
+      const ret = Object.entries(getObject(arg0));
+      return addHeapObject(ret);
+    },
+    __wbindgen_bigint_get_as_i64: function (arg0, arg1) {
+      const v = getObject(arg1);
+      const ret = typeof (v) === "bigint" ? v : undefined;
+      getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0n : ret;
+      getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    },
+    __wbindgen_debug_string: function (arg0, arg1) {
+      const ret = debugString(getObject(arg1));
+      const ptr0 = passStringToWasm0(
+        ret,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
+      const len0 = WASM_VECTOR_LEN;
+      getInt32Memory0()[arg0 / 4 + 1] = len0;
+      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    },
     __wbindgen_throw: function (arg0, arg1) {
       throw new Error(getStringFromWasm0(arg0, arg1));
     },
@@ -449,38 +667,44 @@ const imports = {
       const ret = false;
       return ret;
     },
-    __wbg_then_1c698eedca15eed6: function (arg0, arg1) {
+    __wbg_then_11f7a54d67b4bfad: function (arg0, arg1) {
       const ret = getObject(arg0).then(getObject(arg1));
       return addHeapObject(ret);
     },
-    __wbg_then_4debc41d4fc92ce5: function (arg0, arg1, arg2) {
+    __wbg_then_cedad20fbbd9418a: function (arg0, arg1, arg2) {
       const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
       return addHeapObject(ret);
     },
-    __wbindgen_closure_wrapper9485: function (arg0, arg1, arg2) {
-      const ret = makeMutClosure(arg0, arg1, 143, __wbg_adapter_18);
+    __wbindgen_closure_wrapper7365: function (arg0, arg1, arg2) {
+      const ret = makeMutClosure(arg0, arg1, 272, __wbg_adapter_40);
       return addHeapObject(ret);
     },
   },
 };
 
-const wasm_url = new URL("eszip_wasm_bg.wasm", import.meta.url);
-
 /**
  * Decompression callback
  *
- * @callback decompressCallback
+ * @callback DecompressCallback
  * @param {Uint8Array} compressed
  * @return {Uint8Array} decompressed
  */
 
+/**
+ * Options for instantiating a Wasm instance.
+ * @typedef {Object} InstantiateOptions
+ * @property {URL=} url - Optional url to the Wasm file to instantiate.
+ * @property {DecompressCallback=} decompress - Callback to decompress the
+ * raw Wasm file bytes before instantiating.
+ */
+
 /** Instantiates an instance of the Wasm module returning its functions.
  * @remarks It is safe to call this multiple times and once successfully
  * loaded it will always return a reference to the same object.
- * @param {decompressCallback=} transform
+ * @param {InstantiateOptions=} opts
  */
-export async function instantiate(transform) {
-  return (await instantiateWithInstance(transform)).exports;
+export async function instantiate(opts) {
+  return (await instantiateWithInstance(opts)).exports;
 }
 
 let instanceWithExports;
@@ -489,20 +713,20 @@ let lastLoadPromise;
 /** Instantiates an instance of the Wasm module along with its exports.
  * @remarks It is safe to call this multiple times and once successfully
  * loaded it will always return a reference to the same object.
- * @param {decompressCallback=} transform
+ * @param {InstantiateOptions=} opts
  * @returns {Promise<{
  *   instance: WebAssembly.Instance;
  *   exports: { build: typeof build; Parser : typeof Parser  }
  * }>}
  */
-export function instantiateWithInstance(transform) {
+export function instantiateWithInstance(opts) {
   if (instanceWithExports != null) {
     return Promise.resolve(instanceWithExports);
   }
   if (lastLoadPromise == null) {
     lastLoadPromise = (async () => {
       try {
-        const instance = (await instantiateModule(transform)).instance;
+        const instance = (await instantiateModule(opts ?? {})).instance;
         wasm = instance.exports;
         cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
         cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
@@ -528,36 +752,48 @@ export function isInstantiated() {
   return instanceWithExports != null;
 }
 
-async function instantiateModule(transform) {
-  switch (wasm_url.protocol) {
-    case "file:": {
-      if (typeof Deno !== "object") {
-        throw new Error("file urls are not supported in this environment");
-      }
+/**
+ * @param {InstantiateOptions} opts
+ */
+async function instantiateModule(opts) {
+  const wasmUrl = opts.url ?? new URL("eszip_wasm_bg.wasm", import.meta.url);
+  const decompress = opts.decompress;
+  const isFile = wasmUrl.protocol === "file:";
+
+  // make file urls work in Node via dnt
+  const isNode = globalThis.process?.versions?.node != null;
+  if (isNode && isFile) {
+    // the deno global will be shimmed by dnt
+    const wasmCode = await Deno.readFile(wasmUrl);
+    return WebAssembly.instantiate(
+      decompress ? decompress(wasmCode) : wasmCode,
+      imports,
+    );
+  }
 
-      if ("permissions" in Deno) {
-        Deno.permissions.request({ name: "read", path: wasm_url });
-      }
-      const wasmCode = await Deno.readFile(wasm_url);
-      return WebAssembly.instantiate(
-        !transform ? wasmCode : transform(wasmCode),
-        imports,
-      );
-    }
+  switch (wasmUrl.protocol) {
+    case "file:":
     case "https:":
     case "http:": {
-      if (typeof Deno === "object" && "permissions" in Deno) {
-        Deno.permissions.request({ name: "net", host: wasm_url.host });
+      if (isFile) {
+        if (typeof Deno !== "object") {
+          throw new Error("file urls are not supported in this environment");
+        }
+        if ("permissions" in Deno) {
+          await Deno.permissions.request({ name: "read", path: wasmUrl });
+        }
+      } else if (typeof Deno === "object" && "permissions" in Deno) {
+        await Deno.permissions.request({ name: "net", host: wasmUrl.host });
       }
-      const wasmResponse = await fetch(wasm_url);
-      if (transform) {
+      const wasmResponse = await fetch(wasmUrl);
+      if (decompress) {
         const wasmCode = new Uint8Array(await wasmResponse.arrayBuffer());
-        return WebAssembly.instantiate(transform(wasmCode), imports);
+        return WebAssembly.instantiate(decompress(wasmCode), imports);
       }
       if (
-        wasmResponse.headers.get("content-type")?.toLowerCase().startsWith(
-          "application/wasm",
-        )
+        isFile ||
+        wasmResponse.headers.get("content-type")?.toLowerCase()
+          .startsWith("application/wasm")
       ) {
         return WebAssembly.instantiateStreaming(wasmResponse, imports);
       } else {
@@ -568,6 +804,6 @@ async function instantiateModule(transform) {
       }
     }
     default:
-      throw new Error(`Unsupported protocol: ${wasm_url.protocol}`);
+      throw new Error(`Unsupported protocol: ${wasmUrl.protocol}`);
   }
 }

package/deno/vendor/deno.land/x/{eszip@v0.28.0 → eszip@v0.37.0}/loader.ts

@@ -17,7 +17,7 @@ export interface LoadResponseModule {
 export interface LoadResponseExternalBuiltIn {
   /** The loaded module is either _external_ or _built-in_ to the runtime. */
   kind: "external" | "builtIn";
-  /** The strung URL of the resource. If there were redirects, the final
+  /** The string URL of the resource. If there were redirects, the final
    * specifier should be set here, otherwise the requested specifier. */
   specifier: string;
 }