123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509
// @generated file from wasmbuild -- do not edit// deno-lint-ignore-file// deno-fmt-ignore-file// source-hash: 0859be0712af70e29cbf0299357dbbe691a40bcblet wasm;
const cachedTextDecoder = new TextDecoder("utf-8", {  ignoreBOM: true,  fatal: true,});
cachedTextDecoder.decode();
let cachedUint8Memory0;function getUint8Memory0() {  if (cachedUint8Memory0.byteLength === 0) {    cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);  }  return cachedUint8Memory0;}
function getStringFromWasm0(ptr, len) {  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));}
const heap = new Array(32).fill(undefined);
heap.push(undefined, null, true, false);
let heap_next = heap.length;
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 getObject(idx) {  return heap[idx];}
let WASM_VECTOR_LEN = 0;
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;}
let cachedInt32Memory0;function getInt32Memory0() {  if (cachedInt32Memory0.byteLength === 0) {    cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);  }  return cachedInt32Memory0;}
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;}
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) => {  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_16(arg0, arg1, arg2) {  wasm    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf4a79c8812bc7fa0(      arg0,      arg1,      addHeapObject(arg2),    );}
function isLikeNone(x) {  return x === undefined || x === null;}/** * @param {string} root_specifier * @param {boolean} include_all * @param {Function} load * @param {Function | undefined} maybe_resolve * @param {string | undefined} maybe_import_map * @returns {Promise<any>} */export function doc(  root_specifier,  include_all,  load,  maybe_resolve,  maybe_import_map,) {  const ptr0 = passStringToWasm0(    root_specifier,    wasm.__wbindgen_malloc,    wasm.__wbindgen_realloc,  );  const len0 = WASM_VECTOR_LEN;  var ptr1 = isLikeNone(maybe_import_map)    ? 0    : passStringToWasm0(      maybe_import_map,      wasm.__wbindgen_malloc,      wasm.__wbindgen_realloc,    );  var len1 = WASM_VECTOR_LEN;  const ret = wasm.doc(    ptr0,    len0,    include_all,    addHeapObject(load),    isLikeNone(maybe_resolve) ? 0 : addHeapObject(maybe_resolve),    ptr1,    len1,  );  return takeObject(ret);}
function handleError(f, args) {  try {    return f.apply(this, args);  } catch (e) {    wasm.__wbindgen_exn_store(addHeapObject(e));  }}function __wbg_adapter_32(arg0, arg1, arg2, arg3) {  wasm.wasm_bindgen__convert__closures__invoke2_mut__hda03e6957735bafd(    arg0,    arg1,    addHeapObject(arg2),    addHeapObject(arg3),  );}
const imports = {  __wbindgen_placeholder__: {    __wbindgen_json_parse: function (arg0, arg1) {      const ret = JSON.parse(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;    },    __wbindgen_object_drop_ref: function (arg0) {      takeObject(arg0);    },    __wbg_warn_18c136a79713e57b: function (arg0, arg1) {      console.warn(getStringFromWasm0(arg0, arg1));    },    __wbindgen_string_new: function (arg0, arg1) {      const ret = getStringFromWasm0(arg0, arg1);      return addHeapObject(ret);    },    __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);      }    },    __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_new_651776e932b7e9c7: function (arg0, arg1) {      const ret = new Error(getStringFromWasm0(arg0, arg1));      return addHeapObject(ret);    },    __wbg_call_9855a4612eb496cb: function () {      return handleError(function (arg0, arg1, arg2) {        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));        return addHeapObject(ret);      }, arguments);    },    __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_32(a, state0.b, arg0, arg1);          } finally {            state0.a = a;          }        };        const ret = new Promise(cb0);        return addHeapObject(ret);      } finally {        state0.a = state0.b = 0;      }    },    __wbg_resolve_f269ce174f88b294: function (arg0) {      const ret = Promise.resolve(getObject(arg0));      return addHeapObject(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_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));    },    __wbindgen_closure_wrapper1051: function (arg0, arg1, arg2) {      const ret = makeMutClosure(arg0, arg1, 203, __wbg_adapter_16);      return addHeapObject(ret);    },  },};
const wasm_url = new URL("deno_doc_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: { doc: typeof doc } * }>} */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 { doc };}
/** 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}`);  }}