123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574
// @generated file from wasmbuild -- do not edit// deno-lint-ignore-file// deno-fmt-ignore-file// source-hash: 0e24dd809865bd2b3c39b005f133376180af8ad2let 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}`);  }}