"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _WasmBuildLoader_instances, _WasmBuildLoader_options, _WasmBuildLoader_lastLoadPromise, _WasmBuildLoader_instantiated, _WasmBuildLoader_instantiate;
Object.defineProperty(exports, "__esModule", { value: true });
exports.fetchWithRetries = exports.cacheToLocalDir = exports.isInstantiated = exports.instantiateWithInstance = exports.instantiate = exports.Parser = exports.build = void 0;
// @generated file from wasmbuild -- do not edit
const dntShim = __importStar(require("./_dnt.shims.js"));
// @ts-nocheck: generated
// deno-lint-ignore-file
// deno-fmt-ignore-file
// source-hash: a55265c2eccc2a0fa390e1bcfdab3165cdd8071e
let wasm;
const cachedTextDecoder = typeof TextDecoder !== "undefined"
    ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true })
    : {
        decode: () => {
            throw Error("TextDecoder not available");
        },
    };
if (typeof TextDecoder !== "undefined")
    cachedTextDecoder.decode();
let cachedUint8Memory0 = null;
function getUint8Memory0() {
    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
    }
    return cachedUint8Memory0;
}
function getStringFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
}
const heap = new Array(128).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];
}
function isLikeNone(x) {
    return x === undefined || x === null;
}
let cachedFloat64Memory0 = null;
function getFloat64Memory0() {
    if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
        cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
    }
    return cachedFloat64Memory0;
}
let cachedInt32Memory0 = null;
function getInt32Memory0() {
    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
    }
    return cachedInt32Memory0;
}
let WASM_VECTOR_LEN = 0;
const cachedTextEncoder = typeof TextEncoder !== "undefined"
    ? new TextEncoder("utf-8")
    : {
        encode: () => {
            throw Error("TextEncoder not available");
        },
    };
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, 1) >>> 0;
        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
        WASM_VECTOR_LEN = buf.length;
        return ptr;
    }
    let len = arg.length;
    let ptr = malloc(len, 1) >>> 0;
    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, 1) >>> 0;
        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
        const ret = encodeString(arg, view);
        offset += ret.written;
        ptr = realloc(ptr, len, offset, 1) >>> 0;
    }
    WASM_VECTOR_LEN = offset;
    return ptr;
}
function dropObject(idx) {
    if (idx < 132)
        return;
    heap[idx] = heap_next;
    heap_next = idx;
}
function takeObject(idx) {
    const ret = getObject(idx);
    dropObject(idx);
    return ret;
}
let cachedBigInt64Memory0 = null;
function getBigInt64Memory0() {
    if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
        cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
    }
    return cachedBigInt64Memory0;
}
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 = (typeof FinalizationRegistry === "undefined")
    ? { register: () => { }, unregister: () => { } }
    : 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_46(arg0, arg1, arg2) {
    wasm
        ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha24ab10cf211454d(arg0, arg1, addHeapObject(arg2));
}
function passArray8ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 1, 1) >>> 0;
    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>}
 */
function build(roots, loader, import_map_url) {
    const ret = wasm.build(addHeapObject(roots), addHeapObject(loader), addHeapObject(import_map_url));
    return takeObject(ret);
}
exports.build = build;
function handleError(f, args) {
    try {
        return f.apply(this, args);
    }
    catch (e) {
        wasm.__wbindgen_exn_store(addHeapObject(e));
    }
}
function __wbg_adapter_120(arg0, arg1, arg2, arg3) {
    wasm.wasm_bindgen__convert__closures__invoke2_mut__ha7e6893cb623f1e5(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
}
const ParserFinalization = (typeof FinalizationRegistry === "undefined")
    ? { register: () => { }, unregister: () => { } }
    : new FinalizationRegistry((ptr) => wasm.__wbg_parser_free(ptr >>> 0));
/** */
class Parser {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_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();
        this.__wbg_ptr = ret >>> 0;
        return this;
    }
    /**
     * Parse from a BYOB readable stream.
     * @param {ReadableStreamBYOBReader} stream
     * @returns {Promise<any>}
     */
    parse(stream) {
        const ret = wasm.parser_parse(this.__wbg_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.__wbg_ptr, ptr0, len0);
        return takeObject(ret);
    }
    /**
     * Load module sources.
     * @returns {Promise<any>}
     */
    load() {
        const ret = wasm.parser_load(this.__wbg_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.__wbg_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.__wbg_ptr, ptr0, len0);
        return takeObject(ret);
    }
}
exports.Parser = Parser;
const imports = {
    __wbindgen_placeholder__: {
        __wbg_length_cd7af8117672b8b8: function (arg0) {
            const ret = getObject(arg0).length;
            return ret;
        },
        __wbg_iterator_2cee6dadfd956dfa: function () {
            const ret = Symbol.iterator;
            return addHeapObject(ret);
        },
        __wbindgen_error_new: function (arg0, arg1) {
            const ret = new Error(getStringFromWasm0(arg0, arg1));
            return addHeapObject(ret);
        },
        __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;
            var ptr1 = isLikeNone(ret)
                ? 0
                : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
            var len1 = WASM_VECTOR_LEN;
            getInt32Memory0()[arg0 / 4 + 1] = len1;
            getInt32Memory0()[arg0 / 4 + 0] = ptr1;
        },
        __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_5dd86ebc917d9f52: function (arg0, arg1) {
            const ret = new TypeError(getStringFromWasm0(arg0, arg1));
            return addHeapObject(ret);
        },
        __wbg_new_16b304a2cfa7ff4a: function () {
            const ret = new Array();
            return addHeapObject(ret);
        },
        __wbindgen_string_new: function (arg0, arg1) {
            const ret = getStringFromWasm0(arg0, arg1);
            return addHeapObject(ret);
        },
        __wbg_push_a5b05aedc7234f9f: function (arg0, arg1) {
            const ret = getObject(arg0).push(getObject(arg1));
            return ret;
        },
        __wbg_new_28c511d9baebfa89: 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_12d079cc21e14bdb: function (arg0) {
            const ret = getObject(arg0).buffer;
            return addHeapObject(ret);
        },
        __wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb: function (arg0, arg1, arg2) {
            const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
            return addHeapObject(ret);
        },
        __wbg_new_63b92bc8671ed464: function (arg0) {
            const ret = new Uint8Array(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_String_88810dfeb4021902: function (arg0, arg1) {
            const ret = String(getObject(arg1));
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
            const len1 = WASM_VECTOR_LEN;
            getInt32Memory0()[arg0 / 4 + 1] = len1;
            getInt32Memory0()[arg0 / 4 + 0] = ptr1;
        },
        __wbindgen_jsval_eq: function (arg0, arg1) {
            const ret = getObject(arg0) === getObject(arg1);
            return ret;
        },
        __wbg_readDirSync_11315911ce928716: function () {
            return handleError(function (arg0, arg1) {
                const ret = dntShim.Deno.readDirSync(getStringFromWasm0(arg0, arg1));
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_instanceof_Error_e20bb56fd5591a93: function (arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof Error;
            }
            catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_name_e7429f0dda6079e2: function (arg0) {
            const ret = getObject(arg0).name;
            return addHeapObject(ret);
        },
        __wbindgen_object_clone_ref: function (arg0) {
            const ret = getObject(arg0);
            return addHeapObject(ret);
        },
        __wbg_newwithlength_e9b4878cebadb3d3: function (arg0) {
            const ret = new Uint8Array(arg0 >>> 0);
            return addHeapObject(ret);
        },
        __wbg_read_57beac96bf2997c2: function (arg0, arg1) {
            const ret = getObject(arg0).read(getObject(arg1));
            return addHeapObject(ret);
        },
        __wbg_done_1c9555f2eaa593e9: function (arg0) {
            const ret = getObject(arg0).done;
            return ret;
        },
        __wbg_toString_c816a20ab859d0c1: function (arg0) {
            const ret = getObject(arg0).toString();
            return addHeapObject(ret);
        },
        __wbg_value_a5e55ed0660d29ac: function (arg0) {
            const ret = getObject(arg0).value;
            return isLikeNone(ret) ? 0 : addHeapObject(ret);
        },
        __wbg_byteLength_58f7b4fab1919d44: function (arg0) {
            const ret = getObject(arg0).byteLength;
            return ret;
        },
        __wbg_length_c20a40f15020d68a: function (arg0) {
            const ret = getObject(arg0).length;
            return ret;
        },
        __wbg_new_72fb9a18b5ae2624: function () {
            const ret = new Object();
            return addHeapObject(ret);
        },
        __wbg_set_841ac57cff3d672b: function (arg0, arg1, arg2) {
            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
        },
        __wbg_call_8e7cb608789c2528: function () {
            return handleError(function (arg0, arg1, arg2, arg3) {
                const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_resolve_b0083a7967828ec8: function (arg0) {
            const ret = Promise.resolve(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_new_81740750da40724f: 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_120(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_abda76e883ba8a5f: function () {
            const ret = new Error();
            return addHeapObject(ret);
        },
        __wbg_stack_658279fe44541cf6: function (arg0, arg1) {
            const ret = getObject(arg1).stack;
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
            const len1 = WASM_VECTOR_LEN;
            getInt32Memory0()[arg0 / 4 + 1] = len1;
            getInt32Memory0()[arg0 / 4 + 0] = ptr1;
        },
        __wbg_error_f851667af71bcfc6: function (arg0, arg1) {
            let deferred0_0;
            let deferred0_1;
            try {
                deferred0_0 = arg0;
                deferred0_1 = arg1;
                console.error(getStringFromWasm0(arg0, arg1));
            }
            finally {
                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
            }
        },
        __wbindgen_object_drop_ref: function (arg0) {
            takeObject(arg0);
        },
        __wbindgen_is_function: function (arg0) {
            const ret = typeof (getObject(arg0)) === "function";
            return ret;
        },
        __wbg_call_27c0f87801dedf93: function () {
            return handleError(function (arg0, arg1) {
                const ret = getObject(arg0).call(getObject(arg1));
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_get_bd8e338fbd5f5cc8: function (arg0, arg1) {
            const ret = getObject(arg0)[arg1 >>> 0];
            return addHeapObject(ret);
        },
        __wbg_next_196c84450b364254: function () {
            return handleError(function (arg0) {
                const ret = getObject(arg0).next();
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_done_298b57d23c0fc80c: function (arg0) {
            const ret = getObject(arg0).done;
            return ret;
        },
        __wbg_value_d93c65011f51a456: function (arg0) {
            const ret = getObject(arg0).value;
            return addHeapObject(ret);
        },
        __wbg_next_40fc327bfc8770e6: function (arg0) {
            const ret = getObject(arg0).next;
            return addHeapObject(ret);
        },
        __wbg_get_e3c254076557e348: function () {
            return handleError(function (arg0, arg1) {
                const ret = Reflect.get(getObject(arg0), getObject(arg1));
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_self_ce0dbfc45cf2f5be: function () {
            return handleError(function () {
                const ret = self.self;
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_window_c6fb939a7f436783: function () {
            return handleError(function () {
                const ret = globalThis.window;
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_globalThis_d1e6af4856ba331b: function () {
            return handleError(function () {
                const ret = globalThis.globalThis;
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_global_207b558942527489: function () {
            return handleError(function () {
                const ret = global.global;
                return addHeapObject(ret);
            }, arguments);
        },
        __wbindgen_is_undefined: function (arg0) {
            const ret = getObject(arg0) === undefined;
            return ret;
        },
        __wbg_newnoargs_e258087cd0daa0ea: function (arg0, arg1) {
            const ret = new Function(getStringFromWasm0(arg0, arg1));
            return addHeapObject(ret);
        },
        __wbg_isArray_2ab64d95e09ea0ae: function (arg0) {
            const ret = Array.isArray(getObject(arg0));
            return ret;
        },
        __wbg_message_5bf28016c2b49cfb: function (arg0) {
            const ret = getObject(arg0).message;
            return addHeapObject(ret);
        },
        __wbg_call_b3ca7c6051f9bec1: function () {
            return handleError(function (arg0, arg1, arg2) {
                const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
                return addHeapObject(ret);
            }, arguments);
        },
        __wbg_isSafeInteger_f7b04ef02296c4d2: function (arg0) {
            const ret = Number.isSafeInteger(getObject(arg0));
            return ret;
        },
        __wbg_set_a47bac70306a19a7: 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_2b3bbecd033d19f6: function (arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof Uint8Array;
            }
            catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_instanceof_ArrayBuffer_836825be07d4c9d2: function (arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof ArrayBuffer;
            }
            catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_entries_95cc2c823b285a09: function (arg0) {
            const ret = Object.entries(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_static_accessor_BUILD_1b10d4ca252911e5: function () {
            const ret = dntShim.Deno.build;
            return addHeapObject(ret);
        },
        __wbg_instanceof_Date_f65cf97fb83fc369: function (arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof Date;
            }
            catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_getTime_2bc4375165f02d15: function (arg0) {
            const ret = getObject(arg0).getTime();
            return ret;
        },
        __wbindgen_is_null: function (arg0) {
            const ret = getObject(arg0) === null;
            return 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) ? BigInt(0) : ret;
            getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
        },
        __wbindgen_debug_string: function (arg0, arg1) {
            const ret = debugString(getObject(arg1));
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
            const len1 = WASM_VECTOR_LEN;
            getInt32Memory0()[arg0 / 4 + 1] = len1;
            getInt32Memory0()[arg0 / 4 + 0] = ptr1;
        },
        __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_0c86a60e8fcfe9f6: function (arg0, arg1) {
            const ret = getObject(arg0).then(getObject(arg1));
            return addHeapObject(ret);
        },
        __wbg_queueMicrotask_481971b0d87f3dd4: function (arg0) {
            queueMicrotask(getObject(arg0));
        },
        __wbg_then_a73caa9a87991566: function (arg0, arg1, arg2) {
            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
            return addHeapObject(ret);
        },
        __wbg_queueMicrotask_3cbae2ec6b6cd3d6: function (arg0) {
            const ret = getObject(arg0).queueMicrotask;
            return addHeapObject(ret);
        },
        __wbindgen_closure_wrapper10270: function (arg0, arg1, arg2) {
            const ret = makeMutClosure(arg0, arg1, 808, __wbg_adapter_46);
            return addHeapObject(ret);
        },
    },
};
class WasmBuildLoader {
    constructor(options) {
        _WasmBuildLoader_instances.add(this);
        _WasmBuildLoader_options.set(this, void 0);
        _WasmBuildLoader_lastLoadPromise.set(this, void 0);
        _WasmBuildLoader_instantiated.set(this, void 0);
        __classPrivateFieldSet(this, _WasmBuildLoader_options, options, "f");
    }
    get instance() {
        return __classPrivateFieldGet(this, _WasmBuildLoader_instantiated, "f")?.instance;
    }
    get module() {
        return __classPrivateFieldGet(this, _WasmBuildLoader_instantiated, "f")?.module;
    }
    load(url, decompress) {
        if (__classPrivateFieldGet(this, _WasmBuildLoader_instantiated, "f")) {
            return Promise.resolve(__classPrivateFieldGet(this, _WasmBuildLoader_instantiated, "f"));
        }
        else if (__classPrivateFieldGet(this, _WasmBuildLoader_lastLoadPromise, "f") == null) {
            __classPrivateFieldSet(this, _WasmBuildLoader_lastLoadPromise, (async () => {
                try {
                    __classPrivateFieldSet(this, _WasmBuildLoader_instantiated, await __classPrivateFieldGet(this, _WasmBuildLoader_instances, "m", _WasmBuildLoader_instantiate).call(this, url, decompress), "f");
                    return __classPrivateFieldGet(this, _WasmBuildLoader_instantiated, "f");
                }
                finally {
                    __classPrivateFieldSet(this, _WasmBuildLoader_lastLoadPromise, undefined, "f");
                }
            })(), "f");
        }
        return __classPrivateFieldGet(this, _WasmBuildLoader_lastLoadPromise, "f");
    }
}
_WasmBuildLoader_options = new WeakMap(), _WasmBuildLoader_lastLoadPromise = new WeakMap(), _WasmBuildLoader_instantiated = new WeakMap(), _WasmBuildLoader_instances = new WeakSet(), _WasmBuildLoader_instantiate = async function _WasmBuildLoader_instantiate(url, decompress) {
    const imports = __classPrivateFieldGet(this, _WasmBuildLoader_options, "f").imports;
    if (__classPrivateFieldGet(this, _WasmBuildLoader_options, "f").cache != null && url.protocol !== "file:") {
        try {
            const result = await __classPrivateFieldGet(this, _WasmBuildLoader_options, "f").cache(url, decompress ?? ((bytes) => bytes));
            if (result instanceof URL) {
                url = result;
                decompress = undefined; // already decompressed
            }
            else if (result != null) {
                return WebAssembly.instantiate(result, imports);
            }
        }
        catch {
            // ignore if caching ever fails (ex. when on deploy)
        }
    }
    const isFile = url.protocol === "file:";
    let Deno;
    // make file urls work in Node via dnt
    const isNode = globalThis.process?.versions?.node != null;
    if (isNode) {
        const { readFile } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
        Deno = {
            readFile,
        };
    }
    if (isFile && typeof Deno !== "object") {
        throw new Error("Loading local files are not supported in this environment");
    }
    if (isNode && isFile) {
        // the deno global will be shimmed by dnt
        const wasmCode = await Deno.readFile(url);
        return WebAssembly.instantiate(decompress ? decompress(wasmCode) : wasmCode, imports);
    }
    switch (url.protocol) {
        case "file:":
        case "https:":
        case "http:": {
            const wasmResponse = await fetchWithRetries(url);
            if (decompress) {
                const wasmCode = new Uint8Array(await wasmResponse.arrayBuffer());
                return WebAssembly.instantiate(decompress(wasmCode), imports);
            }
            if (isFile ||
                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: ${url.protocol}`);
    }
};
const isNodeOrDeno = typeof dntShim.Deno === "object" ||
    (typeof process !== "undefined" && process.versions != null &&
        process.versions.node != null);
const loader = new WasmBuildLoader({
    imports,
    cache: isNodeOrDeno ? cacheToLocalDir : undefined,
});
async function instantiate(opts) {
    return (await instantiateWithInstance(opts)).exports;
}
exports.instantiate = instantiate;
async function instantiateWithInstance(opts) {
    const { instance } = await loader.load(opts?.url ?? new URL("eszip_wasm_bg.wasm", require("url").pathToFileURL(__filename).href), opts?.decompress);
    wasm = wasm ?? instance.exports;
    cachedInt32Memory0 = cachedInt32Memory0 ?? new Int32Array(wasm.memory.buffer);
    cachedUint8Memory0 = cachedUint8Memory0 ?? new Uint8Array(wasm.memory.buffer);
    return {
        instance,
        exports: getWasmInstanceExports(),
    };
}
exports.instantiateWithInstance = instantiateWithInstance;
function getWasmInstanceExports() {
    return { build, Parser };
}
function isInstantiated() {
    return loader.instance != null;
}
exports.isInstantiated = isInstantiated;
async function cacheToLocalDir(url, decompress) {
    const localPath = await getUrlLocalPath(url);
    if (localPath == null) {
        return undefined;
    }
    if (!await exists(localPath)) {
        const fileBytes = decompress(new Uint8Array(await getUrlBytes(url)));
        try {
            await dntShim.Deno.writeFile(localPath, fileBytes);
        }
        catch {
            // ignore and return the wasm bytes
            return fileBytes;
        }
    }
    return toFileUrl(localPath);
}
exports.cacheToLocalDir = cacheToLocalDir;
async function getUrlLocalPath(url) {
    try {
        const dataDirPath = await getInitializedLocalDataDirPath();
        const hash = await getUrlHash(url);
        return `${dataDirPath}/${hash}.wasm`;
    }
    catch {
        return undefined;
    }
}
async function getInitializedLocalDataDirPath() {
    const dataDir = localDataDir();
    if (dataDir == null) {
        throw new Error(`Could not find local data directory.`);
    }
    const dirPath = `${dataDir}/deno-wasmbuild`;
    await ensureDir(dirPath);
    return dirPath;
}
async function exists(filePath) {
    try {
        await dntShim.Deno.lstat(filePath);
        return true;
    }
    catch (error) {
        if (error instanceof dntShim.Deno.errors.NotFound) {
            return false;
        }
        throw error;
    }
}
async function ensureDir(dir) {
    try {
        const fileInfo = await dntShim.Deno.lstat(dir);
        if (!fileInfo.isDirectory) {
            throw new Error(`Path was not a directory '${dir}'`);
        }
    }
    catch (err) {
        if (err instanceof dntShim.Deno.errors.NotFound) {
            // if dir not exists. then create it.
            await dntShim.Deno.mkdir(dir, { recursive: true });
            return;
        }
        throw err;
    }
}
async function getUrlHash(url) {
    // Taken from MDN: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
    const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(url.href));
    // convert buffer to byte array
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    // convert bytes to hex string
    const hashHex = hashArray
        .map((b) => b.toString(16).padStart(2, "0"))
        .join("");
    return hashHex;
}
async function getUrlBytes(url) {
    const response = await fetchWithRetries(url);
    return await response.arrayBuffer();
}
// the below is extracted from deno_std/path
const WHITESPACE_ENCODINGS = {
    "\u0009": "%09",
    "\u000A": "%0A",
    "\u000B": "%0B",
    "\u000C": "%0C",
    "\u000D": "%0D",
    "\u0020": "%20",
};
function encodeWhitespace(string) {
    return string.replaceAll(/[\s]/g, (c) => {
        return WHITESPACE_ENCODINGS[c] ?? c;
    });
}
function toFileUrl(path) {
    return dntShim.Deno.build.os === "windows"
        ? windowsToFileUrl(path)
        : posixToFileUrl(path);
}
function posixToFileUrl(path) {
    const url = new URL("file:///");
    url.pathname = encodeWhitespace(path.replace(/%/g, "%25").replace(/\\/g, "%5C"));
    return url;
}
function windowsToFileUrl(path) {
    const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
    const url = new URL("file:///");
    url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
    if (hostname != null && hostname != "localhost") {
        url.hostname = hostname;
        if (!url.hostname) {
            throw new TypeError("Invalid hostname.");
        }
    }
    return url;
}
async function fetchWithRetries(url, maxRetries = 5) {
    let sleepMs = 250;
    let iterationCount = 0;
    while (true) {
        iterationCount++;
        try {
            const res = await dntShim.fetch(url);
            if (res.ok || iterationCount > maxRetries) {
                return res;
            }
        }
        catch (err) {
            if (iterationCount > maxRetries) {
                throw err;
            }
        }
        console.warn(`Failed fetching. Retrying in ${sleepMs}ms...`);
        await new Promise((resolve) => setTimeout(resolve, sleepMs));
        sleepMs = Math.min(sleepMs * 2, 10000);
    }
}
exports.fetchWithRetries = fetchWithRetries;
// MIT License - Copyright (c) justjavac.
// https://github.com/justjavac/deno_dirs/blob/e8c001bbef558f08fd486d444af391729b0b8068/data_local_dir/mod.ts
function localDataDir() {
    switch (dntShim.Deno.build.os) {
        case "linux": {
            const xdg = dntShim.Deno.env.get("XDG_DATA_HOME");
            if (xdg) {
                return xdg;
            }
            const home = dntShim.Deno.env.get("HOME");
            if (home) {
                return `${home}/.local/share`;
            }
            break;
        }
        case "darwin": {
            const home = dntShim.Deno.env.get("HOME");
            if (home) {
                return `${home}/Library/Application Support`;
            }
            break;
        }
        case "windows":
            return dntShim.Deno.env.get("LOCALAPPDATA") ?? undefined;
    }
    return undefined;
}
