@netlify/edge-bundler 2.6.0 → 2.7.0

package/deno/vendor/deno.land/x/eszip@v0.28.0/eszip_wasm.generated.js

@@ -0,0 +1,573 @@
+// @generated file from wasmbuild -- do not edit
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+// source-hash: 0e24dd809865bd2b3c39b005f133376180af8ad2
+let wasm;
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) {
+  return heap[idx];
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8Memory0;
+function getUint8Memory0() {
+  if (cachedUint8Memory0.byteLength === 0) {
+    cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8Memory0;
+}
+
+const cachedTextEncoder = new TextEncoder("utf-8");
+
+const encodeString = function (arg, view) {
+  return cachedTextEncoder.encodeInto(arg, view);
+};
+
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr = malloc(buf.length);
+    getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr;
+  }
+
+  let len = arg.length;
+  let ptr = malloc(len);
+
+  const mem = getUint8Memory0();
+
+  let offset = 0;
+
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 0x7F) break;
+    mem[ptr + offset] = code;
+  }
+
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3);
+    const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+    const ret = encodeString(arg, view);
+
+    offset += ret.written;
+  }
+
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
+
+let cachedInt32Memory0;
+function getInt32Memory0() {
+  if (cachedInt32Memory0.byteLength === 0) {
+    cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+  }
+  return cachedInt32Memory0;
+}
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+  if (idx < 36) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+
+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 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;
+}
+
+const CLOSURE_DTORS = new FinalizationRegistry((state) => {
+  wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b);
+});
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+  const state = { a: arg0, b: arg1, cnt: 1, dtor };
+  const real = (...args) => {
+    // First up with a closure we increment the internal reference
+    // count. This ensures that the Rust closure environment won't
+    // be deallocated while we're invoking it.
+    state.cnt++;
+    const a = state.a;
+    state.a = 0;
+    try {
+      return f(a, state.b, ...args);
+    } finally {
+      if (--state.cnt === 0) {
+        wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
+        CLOSURE_DTORS.unregister(state);
+      } else {
+        state.a = a;
+      }
+    }
+  };
+  real.original = state;
+  CLOSURE_DTORS.register(real, state, state);
+  return real;
+}
+function __wbg_adapter_18(arg0, arg1, arg2) {
+  wasm
+    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd4f05ebc54a3a357(
+      arg0,
+      arg1,
+      addHeapObject(arg2),
+    );
+}
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1);
+  getUint8Memory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+/**
+ * Serialize a module graph into eszip.
+ * @param {any} roots
+ * @param {Function} loader
+ * @param {any} import_map_url
+ * @returns {Promise<Uint8Array>}
+ */
+export function build(roots, loader, import_map_url) {
+  const ret = wasm.build(
+    addHeapObject(roots),
+    addHeapObject(loader),
+    addHeapObject(import_map_url),
+  );
+  return takeObject(ret);
+}
+
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    wasm.__wbindgen_exn_store(addHeapObject(e));
+  }
+}
+function __wbg_adapter_50(arg0, arg1, arg2, arg3) {
+  wasm.wasm_bindgen__convert__closures__invoke2_mut__hccb8632b1071bfde(
+    arg0,
+    arg1,
+    addHeapObject(arg2),
+    addHeapObject(arg3),
+  );
+}
+
+const ParserFinalization = new FinalizationRegistry((ptr) =>
+  wasm.__wbg_parser_free(ptr)
+);
+/** */
+export class Parser {
+  static __wrap(ptr) {
+    const obj = Object.create(Parser.prototype);
+    obj.ptr = ptr;
+    ParserFinalization.register(obj, obj.ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.ptr;
+    this.ptr = 0;
+    ParserFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_parser_free(ptr);
+  }
+  /** */
+  constructor() {
+    const ret = wasm.parser_new();
+    return Parser.__wrap(ret);
+  }
+  /**
+   * Parse from a BYOB readable stream.
+   * @param {ReadableStreamBYOBReader} stream
+   * @returns {Promise<any>}
+   */
+  parse(stream) {
+    const ret = wasm.parser_parse(this.ptr, addHeapObject(stream));
+    return takeObject(ret);
+  }
+  /**
+   * Parse from an in-memory buffer.
+   * @param {Uint8Array} buffer
+   * @returns {Promise<any>}
+   */
+  parseBytes(buffer) {
+    const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parser_parseBytes(this.ptr, ptr0, len0);
+    return takeObject(ret);
+  }
+  /**
+   * Load module sources.
+   * @returns {Promise<any>}
+   */
+  load() {
+    const ret = wasm.parser_load(this.ptr);
+    return takeObject(ret);
+  }
+  /**
+   * Get a module source.
+   * @param {string} specifier
+   * @returns {Promise<any>}
+   */
+  getModuleSource(specifier) {
+    const ptr0 = passStringToWasm0(
+      specifier,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parser_getModuleSource(this.ptr, ptr0, len0);
+    return takeObject(ret);
+  }
+  /**
+   * Get a module sourcemap.
+   * @param {string} specifier
+   * @returns {Promise<any>}
+   */
+  getModuleSourceMap(specifier) {
+    const ptr0 = passStringToWasm0(
+      specifier,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parser_getModuleSourceMap(this.ptr, ptr0, len0);
+    return takeObject(ret);
+  }
+}
+
+const imports = {
+  __wbindgen_placeholder__: {
+    __wbindgen_string_get: function (arg0, arg1) {
+      const obj = getObject(arg1);
+      const ret = typeof (obj) === "string" ? obj : undefined;
+      var ptr0 = isLikeNone(ret)
+        ? 0
+        : passStringToWasm0(
+          ret,
+          wasm.__wbindgen_malloc,
+          wasm.__wbindgen_realloc,
+        );
+      var len0 = WASM_VECTOR_LEN;
+      getInt32Memory0()[arg0 / 4 + 1] = len0;
+      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    },
+    __wbindgen_object_drop_ref: function (arg0) {
+      takeObject(arg0);
+    },
+    __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_new_651776e932b7e9c7: function (arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    },
+    __wbindgen_memory: function () {
+      const ret = wasm.memory;
+      return addHeapObject(ret);
+    },
+    __wbg_buffer_de1150f91b23aa89: function (arg0) {
+      const ret = getObject(arg0).buffer;
+      return addHeapObject(ret);
+    },
+    __wbg_newwithbyteoffsetandlength_9ca61320599a2c84: function (
+      arg0,
+      arg1,
+      arg2,
+    ) {
+      const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+      return addHeapObject(ret);
+    },
+    __wbg_new_97cf52648830a70d: function (arg0) {
+      const ret = new Uint8Array(getObject(arg0));
+      return addHeapObject(ret);
+    },
+    __wbg_new_2ab697f1555e0dbc: function () {
+      const ret = new Array();
+      return addHeapObject(ret);
+    },
+    __wbg_push_811c8b08bf4ff9d5: function (arg0, arg1) {
+      const ret = getObject(arg0).push(getObject(arg1));
+      return ret;
+    },
+    __wbg_resolve_f269ce174f88b294: function (arg0) {
+      const ret = Promise.resolve(getObject(arg0));
+      return addHeapObject(ret);
+    },
+    __wbg_newwithlength_e833b89f9db02732: function (arg0) {
+      const ret = new Uint8Array(arg0 >>> 0);
+      return addHeapObject(ret);
+    },
+    __wbg_read_33fc0c1143d99231: function (arg0, arg1) {
+      const ret = getObject(arg0).read(getObject(arg1));
+      return addHeapObject(ret);
+    },
+    __wbg_done_9d9636ea8e221033: 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) {
+      const ret = getObject(arg0).toString();
+      return addHeapObject(ret);
+    },
+    __wbg_value_57cc9a30b585d121: function (arg0) {
+      const ret = getObject(arg0).value;
+      return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    },
+    __wbg_byteLength_cf73ca7a0d44cb85: function (arg0) {
+      const ret = getObject(arg0).byteLength;
+      return ret;
+    },
+    __wbg_length_e09c0b925ab8de5d: 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 () {
+      return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).call(
+          getObject(arg1),
+          getObject(arg2),
+          getObject(arg3),
+        );
+        return addHeapObject(ret);
+      }, arguments);
+    },
+    __wbg_new_78403b138428b684: 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);
+          } finally {
+            state0.a = a;
+          }
+        };
+        const ret = new Promise(cb0);
+        return addHeapObject(ret);
+      } finally {
+        state0.a = state0.b = 0;
+      }
+    },
+    __wbg_new_693216e109162396: function () {
+      const ret = new Error();
+      return addHeapObject(ret);
+    },
+    __wbg_stack_0ddaca5d1abfb52f: function (arg0, arg1) {
+      const ret = getObject(arg1).stack;
+      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_error_09919627ac0992f5: function (arg0, arg1) {
+      try {
+        console.error(getStringFromWasm0(arg0, arg1));
+      } finally {
+        wasm.__wbindgen_free(arg0, arg1);
+      }
+    },
+    __wbg_call_9855a4612eb496cb: function () {
+      return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+      }, arguments);
+    },
+    __wbindgen_throw: function (arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbindgen_cb_drop: function (arg0) {
+      const obj = takeObject(arg0).original;
+      if (obj.cnt-- == 1) {
+        obj.a = 0;
+        return true;
+      }
+      const ret = false;
+      return ret;
+    },
+    __wbg_then_1c698eedca15eed6: function (arg0, arg1) {
+      const ret = getObject(arg0).then(getObject(arg1));
+      return addHeapObject(ret);
+    },
+    __wbg_then_4debc41d4fc92ce5: 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);
+      return addHeapObject(ret);
+    },
+  },
+};
+
+const wasm_url = new URL("eszip_wasm_bg.wasm", import.meta.url);
+
+/**
+ * Decompression callback
+ *
+ * @callback decompressCallback
+ * @param {Uint8Array} compressed
+ * @return {Uint8Array} decompressed
+ */
+
+/** 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
+ */
+export async function instantiate(transform) {
+  return (await instantiateWithInstance(transform)).exports;
+}
+
+let instanceWithExports;
+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
+ * @returns {Promise<{
+ *   instance: WebAssembly.Instance;
+ *   exports: { build: typeof build; Parser : typeof Parser  }
+ * }>}
+ */
+export function instantiateWithInstance(transform) {
+  if (instanceWithExports != null) {
+    return Promise.resolve(instanceWithExports);
+  }
+  if (lastLoadPromise == null) {
+    lastLoadPromise = (async () => {
+      try {
+        const instance = (await instantiateModule(transform)).instance;
+        wasm = instance.exports;
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+        instanceWithExports = {
+          instance,
+          exports: getWasmInstanceExports(),
+        };
+        return instanceWithExports;
+      } finally {
+        lastLoadPromise = null;
+      }
+    })();
+  }
+  return lastLoadPromise;
+}
+
+function getWasmInstanceExports() {
+  return { build, Parser };
+}
+
+/** Gets if the Wasm module has been instantiated. */
+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");
+      }
+
+      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,
+      );
+    }
+    case "https:":
+    case "http:": {
+      if (typeof Deno === "object" && "permissions" in Deno) {
+        Deno.permissions.request({ name: "net", host: wasm_url.host });
+      }
+      const wasmResponse = await fetch(wasm_url);
+      if (transform) {
+        const wasmCode = new Uint8Array(await wasmResponse.arrayBuffer());
+        return WebAssembly.instantiate(transform(wasmCode), imports);
+      }
+      if (
+        wasmResponse.headers.get("content-type")?.toLowerCase().startsWith(
+          "application/wasm",
+        )
+      ) {
+        return WebAssembly.instantiateStreaming(wasmResponse, imports);
+      } else {
+        return WebAssembly.instantiate(
+          await wasmResponse.arrayBuffer(),
+          imports,
+        );
+      }
+    }
+    default:
+      throw new Error(`Unsupported protocol: ${wasm_url.protocol}`);
+  }
+}

package/deno/vendor/deno.land/x/eszip@v0.28.0/loader.ts

@@ -0,0 +1,67 @@
+// Adapted from deno_graph
+// https://github.com/denoland/deno_graph/blob/main/lib/loader.ts
+
+export interface LoadResponseModule {
+  /** A module with code has been loaded. */
+  kind: "module";
+  /** The string URL of the resource. If there were redirects, the final
+   * specifier should be set here, otherwise the requested specifier. */
+  specifier: string;
+  /** For remote resources, a record of headers should be set, where the key's
+   * have been normalized to be lower case values. */
+  headers?: Record<string, string>;
+  /** The string value of the loaded resources. */
+  content: string;
+}
+
+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
+   * specifier should be set here, otherwise the requested specifier. */
+  specifier: string;
+}
+
+export type LoadResponse = LoadResponseModule | LoadResponseExternalBuiltIn;
+
+export async function load(
+  specifier: string,
+): Promise<LoadResponse | undefined> {
+  const url = new URL(specifier);
+  try {
+    switch (url.protocol) {
+      case "file:": {
+        const content = await Deno.readTextFile(url);
+        return {
+          kind: "module",
+          specifier,
+          content,
+        };
+      }
+      case "http:":
+      case "https:": {
+        const response = await fetch(String(url), { redirect: "follow" });
+        if (response.status !== 200) {
+          // ensure the body is read as to not leak resources
+          await response.arrayBuffer();
+          return undefined;
+        }
+        const content = await response.text();
+        const headers: Record<string, string> = {};
+        for (const [key, value] of response.headers) {
+          headers[key.toLowerCase()] = value;
+        }
+        return {
+          kind: "module",
+          specifier: response.url,
+          headers,
+          content,
+        };
+      }
+      default:
+        return undefined;
+    }
+  } catch {
+    return undefined;
+  }
+}

package/deno/vendor/deno.land/x/eszip@v0.28.0/mod.ts

@@ -0,0 +1,33 @@
+import { load, LoadResponse } from "./loader.ts";
+import {
+  instantiate,
+  Parser as InternalParser,
+} from "./eszip_wasm.generated.js";
+
+export type { LoadResponse } from "./loader.ts";
+
+export class Parser extends InternalParser {
+  private constructor() {
+    super();
+  }
+
+  static async createInstance() {
+    // insure instantiate is called
+    await instantiate();
+    return new Parser();
+  }
+}
+
+export async function build(
+  roots: string[],
+  loader: (url: string) => Promise<LoadResponse | undefined> = load,
+  importMapUrl?: string,
+): Promise<Uint8Array> {
+  const { build } = await instantiate();
+  return build(
+    roots,
+    (specifier: string) =>
+      loader(specifier).catch((err) => Promise.reject(String(err))),
+    importMapUrl,
+  );
+}

package/deno/vendor/deno.land/x/retry@v2.0.0/deps.ts

@@ -0,0 +1,5 @@
+// Copyright since 2020, FranckLdx. All rights reserved. MIT license.
+export {
+  deferred,
+  delay as denoDelay,
+} from "https://deno.land/std@0.98.0/async/mod.ts";

package/deno/vendor/deno.land/x/retry@v2.0.0/misc.ts

@@ -0,0 +1,25 @@
+// Copyright since 2020, FranckLdx. All rights reserved. MIT license.
+import { deferred } from "./deps.ts";
+
+export const asyncDecorator = <T>(fn: () => T) => {
+  return (): Promise<T> => {
+    const promise = deferred<T>();
+    try {
+      const result = fn();
+      promise.resolve(result);
+    } catch (err) {
+      promise.reject(err);
+    }
+    return promise;
+  };
+};
+
+export const assertDefined = <T>(
+  value: T | undefined | null,
+  errMsg: string,
+): value is T => {
+  if (value === undefined || value == null) {
+    throw new Error(errMsg);
+  }
+  return true;
+};