@kerebron/tree-sitter 0.4.6

package/esm/deno-tree-sitter/main/wasm_loader.js

@@ -0,0 +1,1709 @@
+// this file is the loader for tree-sitter.wasm, specifically derived from v0.25.3 of web-tree-sitter
+// unlike the normal tree sitter code, this code allows for arguments to be given
+// which allows it to be run on Deno, Web, Webworkers, and Node
+// there is no platform-dependant code in here
+const __name = (thing, name) => thing;
+export const defaults = {
+    arguments: [],
+    dynamicLibraries: [],
+    thisProgram: "./this.program",
+    INITIAL_MEMORY: 33554432,
+    wasmBinary: null,
+    wasmBinaryFilePath: null,
+    noExitRuntime: true,
+    noInitialRun: false,
+    monitorRunDependencies: null, // func
+    onRuntimeInitialized: null, // func
+    preRun: null, // func or array of functions
+    preInit: null, // func or array of functions
+    onAbort: null, // func
+    onExit: null, // func
+    postRun: null, // func or array of functions
+    setStatus: null, // func, string arg of "Running..."
+    defaultWasmPath: "tree-sitter.wasm",
+    quit: (status, toThrow) => {
+        throw toThrow;
+    },
+    locateFile: (relativePath) => {
+        return relativePath;
+    },
+    readAsync: async (path) => { }, // expects Uint8Array output
+    readBinary: (path) => { }, // expects Uint8Array output
+    print: null, // console.log alternative
+    printErr: null, // console.log alternative
+    instantiateWasm: null, //  func(info, receiveInstance), // probably most important
+    fetch: globalThis.fetch,
+    // info2={
+    //     env: wasmImports,
+    //     wasi_snapshot_preview1: wasmImports,
+    //     "GOT.mem": new Proxy(wasmImports, GOTHandler),
+    //     "GOT.func": new Proxy(wasmImports, GOTHandler),
+    // }
+    // needs to call receiveInstance
+    // receiveInstance(instantiationResult["instance"], instantiationResult["module"])
+};
+export default async function (Module) {
+    var _a;
+    Module = Object.assign({}, defaults, Module);
+    var readyPromiseResolve, readyPromiseReject;
+    var readyPromise = new Promise((resolve, reject) => {
+        readyPromiseResolve = resolve;
+        readyPromiseReject = reject;
+    });
+    Module.currentQueryProgressCallback = null;
+    Module.currentProgressCallback = null;
+    Module.currentLogCallback = null;
+    Module.currentParseCallback = null;
+    var { arguments: arguments_, thisProgram, INITIAL_MEMORY, noExitRuntime, dynamicLibraries, wasmBinary, wasmBinaryFilePath, quit: quit_, locateFile, readAsync, readBinary, scriptDirectory, wasmMemory, } = Module;
+    __name(quit_, "quit_");
+    __name(locateFile, "locateFile");
+    __name(readBinary, "readBinary");
+    __name(readAsync, "readAsync");
+    var out = Module["print"] || console.log.bind(console);
+    var err = Module["printErr"] || console.error.bind(console);
+    wasmMemory = wasmMemory || new WebAssembly.Memory({
+        initial: INITIAL_MEMORY / 65536,
+        // In theory we should not need to emit the maximum if we want "unlimited"
+        // or 4GB of memory, but VMs error on that atm, see
+        // https://github.com/emscripten-core/emscripten/issues/14130
+        // And in the pthreads case we definitely need to emit a maximum. So
+        // always emit one.
+        maximum: 32768,
+    });
+    var ABORT = false;
+    var EXITSTATUS;
+    function assert(condition, text) {
+        if (!condition) {
+            abort(text);
+        }
+    }
+    __name(assert, "assert");
+    var HEAP, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
+    var HEAP_DATA_VIEW;
+    var runtimeInitialized = false;
+    var dataURIPrefix = "data:application/octet-stream;base64,";
+    var isUrl = (filename) => {
+        try {
+            new URL(filename);
+        }
+        catch (error) {
+            if (error?.message?.startsWith?.("Invalid URL: ")) {
+                return false;
+            }
+        }
+        return true;
+    };
+    var isDataURI = /* @__PURE__ */ __name((filename) => filename.startsWith(dataURIPrefix), "isDataURI");
+    var isFileURI = /* @__PURE__ */ __name((filename) => filename.startsWith("file://"), "isFileURI");
+    function updateMemoryViews() {
+        var b = wasmMemory.buffer;
+        Module["HEAP_DATA_VIEW"] = HEAP_DATA_VIEW = new DataView(b);
+        Module["HEAP8"] = HEAP8 = new Int8Array(b);
+        Module["HEAP16"] = HEAP16 = new Int16Array(b);
+        Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+        Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
+        Module["HEAP32"] = HEAP32 = new Int32Array(b);
+        Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+        Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
+        Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
+        Module["HEAP64"] = HEAP64 = new BigInt64Array(b);
+        Module["HEAPU64"] = HEAPU64 = new BigUint64Array(b);
+    }
+    __name(updateMemoryViews, "updateMemoryViews");
+    updateMemoryViews();
+    var __ATPRERUN__ = [];
+    var __ATINIT__ = [];
+    var __ATMAIN__ = [];
+    var __ATEXIT__ = [];
+    var __ATPOSTRUN__ = [];
+    var __RELOC_FUNCS__ = [];
+    function preRun() {
+        if (Module["preRun"]) {
+            if (typeof Module["preRun"] == "function")
+                Module["preRun"] = [Module["preRun"]];
+            while (Module["preRun"].length) {
+                addOnPreRun(Module["preRun"].shift());
+            }
+        }
+        callRuntimeCallbacks(__ATPRERUN__);
+    }
+    __name(preRun, "preRun");
+    function initRuntime() {
+        runtimeInitialized = true;
+        callRuntimeCallbacks(__RELOC_FUNCS__);
+        callRuntimeCallbacks(__ATINIT__);
+    }
+    __name(initRuntime, "initRuntime");
+    function preMain() {
+        callRuntimeCallbacks(__ATMAIN__);
+    }
+    __name(preMain, "preMain");
+    function postRun() {
+        if (Module["postRun"]) {
+            if (typeof Module["postRun"] == "function")
+                Module["postRun"] = [Module["postRun"]];
+            while (Module["postRun"].length) {
+                addOnPostRun(Module["postRun"].shift());
+            }
+        }
+        callRuntimeCallbacks(__ATPOSTRUN__);
+    }
+    __name(postRun, "postRun");
+    function addOnPreRun(cb) {
+        __ATPRERUN__.unshift(cb);
+    }
+    __name(addOnPreRun, "addOnPreRun");
+    function addOnInit(cb) {
+        __ATINIT__.unshift(cb);
+    }
+    __name(addOnInit, "addOnInit");
+    function addOnPreMain(cb) {
+        __ATMAIN__.unshift(cb);
+    }
+    __name(addOnPreMain, "addOnPreMain");
+    function addOnExit(cb) { }
+    __name(addOnExit, "addOnExit");
+    function addOnPostRun(cb) {
+        __ATPOSTRUN__.unshift(cb);
+    }
+    __name(addOnPostRun, "addOnPostRun");
+    var runDependencies = 0;
+    var dependenciesFulfilled = null;
+    function getUniqueRunDependency(id) {
+        return id;
+    }
+    __name(getUniqueRunDependency, "getUniqueRunDependency");
+    function addRunDependency(id) {
+        runDependencies++;
+        Module["monitorRunDependencies"]?.(runDependencies);
+    }
+    __name(addRunDependency, "addRunDependency");
+    function removeRunDependency(id) {
+        runDependencies--;
+        Module["monitorRunDependencies"]?.(runDependencies);
+        if (runDependencies == 0) {
+            if (dependenciesFulfilled) {
+                var callback = dependenciesFulfilled;
+                dependenciesFulfilled = null;
+                callback();
+            }
+        }
+    }
+    __name(removeRunDependency, "removeRunDependency");
+    function abort(what) {
+        Module["onAbort"]?.(what);
+        what = "Aborted(" + what + ")";
+        err(what);
+        ABORT = true;
+        what += ". Build with -sASSERTIONS for more info.";
+        var e = new WebAssembly.RuntimeError(what);
+        readyPromiseReject(e);
+        throw e;
+    }
+    __name(abort, "abort");
+    var ASM_CONSTS = {};
+    class ExitStatus {
+        constructor(status) {
+            Object.defineProperty(this, "name", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "ExitStatus"
+            });
+            this.message = `Program terminated with exit(${status})`;
+            this.status = status;
+        }
+    }
+    _a = ExitStatus;
+    (() => {
+        __name(_a, "ExitStatus");
+    })();
+    var GOT = {};
+    var currentModuleWeakSymbols = /* @__PURE__ */ new Set([]);
+    var GOTHandler = {
+        get(obj, symName) {
+            var rtn = GOT[symName];
+            if (!rtn) {
+                rtn = GOT[symName] = new WebAssembly.Global({
+                    value: "i32",
+                    mutable: true,
+                });
+            }
+            if (!currentModuleWeakSymbols.has(symName)) {
+                rtn.required = true;
+            }
+            return rtn;
+        },
+    };
+    var LE_HEAP_LOAD_F32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getFloat32(byteOffset, true), "LE_HEAP_LOAD_F32");
+    var LE_HEAP_LOAD_F64 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getFloat64(byteOffset, true), "LE_HEAP_LOAD_F64");
+    var LE_HEAP_LOAD_I16 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getInt16(byteOffset, true), "LE_HEAP_LOAD_I16");
+    var LE_HEAP_LOAD_I32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getInt32(byteOffset, true), "LE_HEAP_LOAD_I32");
+    var LE_HEAP_LOAD_U16 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getUint16(byteOffset, true), "LE_HEAP_LOAD_U16");
+    var LE_HEAP_LOAD_U32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getUint32(byteOffset, true), "LE_HEAP_LOAD_U32");
+    var LE_HEAP_STORE_F32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setFloat32(byteOffset, value, true), "LE_HEAP_STORE_F32");
+    var LE_HEAP_STORE_F64 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setFloat64(byteOffset, value, true), "LE_HEAP_STORE_F64");
+    var LE_HEAP_STORE_I16 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setInt16(byteOffset, value, true), "LE_HEAP_STORE_I16");
+    var LE_HEAP_STORE_I32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setInt32(byteOffset, value, true), "LE_HEAP_STORE_I32");
+    var LE_HEAP_STORE_U16 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setUint16(byteOffset, value, true), "LE_HEAP_STORE_U16");
+    var LE_HEAP_STORE_U32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setUint32(byteOffset, value, true), "LE_HEAP_STORE_U32");
+    var callRuntimeCallbacks = /* @__PURE__ */ __name((callbacks) => {
+        while (callbacks.length > 0) {
+            callbacks.shift()(Module);
+        }
+    }, "callRuntimeCallbacks");
+    var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : void 0;
+    var UTF8ArrayToString = /* @__PURE__ */ __name((heapOrArray, idx = 0, maxBytesToRead = NaN) => {
+        var endIdx = idx + maxBytesToRead;
+        var endPtr = idx;
+        while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+            ++endPtr;
+        if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+            return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+        }
+        var str = "";
+        while (idx < endPtr) {
+            var u0 = heapOrArray[idx++];
+            if (!(u0 & 128)) {
+                str += String.fromCharCode(u0);
+                continue;
+            }
+            var u1 = heapOrArray[idx++] & 63;
+            if ((u0 & 224) == 192) {
+                str += String.fromCharCode(((u0 & 31) << 6) | u1);
+                continue;
+            }
+            var u2 = heapOrArray[idx++] & 63;
+            if ((u0 & 240) == 224) {
+                u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+            }
+            else {
+                u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+            }
+            if (u0 < 65536) {
+                str += String.fromCharCode(u0);
+            }
+            else {
+                var ch = u0 - 65536;
+                str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+            }
+        }
+        return str;
+    }, "UTF8ArrayToString");
+    var getDylinkMetadata = /* @__PURE__ */ __name((binary2) => {
+        var offset = 0;
+        var end = 0;
+        function getU8() {
+            return binary2[offset++];
+        }
+        __name(getU8, "getU8");
+        function getLEB() {
+            var ret = 0;
+            var mul = 1;
+            while (1) {
+                var byte = binary2[offset++];
+                ret += (byte & 127) * mul;
+                mul *= 128;
+                if (!(byte & 128))
+                    break;
+            }
+            return ret;
+        }
+        __name(getLEB, "getLEB");
+        function getString() {
+            var len = getLEB();
+            offset += len;
+            return UTF8ArrayToString(binary2, offset - len, len);
+        }
+        __name(getString, "getString");
+        function failIf(condition, message) {
+            if (condition)
+                throw new Error(message);
+        }
+        __name(failIf, "failIf");
+        var name2 = "dylink.0";
+        if (binary2 instanceof WebAssembly.Module) {
+            var dylinkSection = WebAssembly.Module.customSections(binary2, name2);
+            if (dylinkSection.length === 0) {
+                name2 = "dylink";
+                dylinkSection = WebAssembly.Module.customSections(binary2, name2);
+            }
+            failIf(dylinkSection.length === 0, "need dylink section");
+            binary2 = new Uint8Array(dylinkSection[0]);
+            end = binary2.length;
+        }
+        else {
+            var int32View = new Uint32Array(new Uint8Array(binary2.subarray(0, 24)).buffer);
+            var magicNumberFound = int32View[0] == 1836278016 || int32View[0] == 6386541;
+            failIf(!magicNumberFound, "need to see wasm magic number");
+            failIf(binary2[8] !== 0, "need the dylink section to be first");
+            offset = 9;
+            var section_size = getLEB();
+            end = offset + section_size;
+            name2 = getString();
+        }
+        var customSection = {
+            neededDynlibs: [],
+            tlsExports: /* @__PURE__ */ new Set(),
+            weakImports: /* @__PURE__ */ new Set(),
+        };
+        if (name2 == "dylink") {
+            customSection.memorySize = getLEB();
+            customSection.memoryAlign = getLEB();
+            customSection.tableSize = getLEB();
+            customSection.tableAlign = getLEB();
+            var neededDynlibsCount = getLEB();
+            for (var i2 = 0; i2 < neededDynlibsCount; ++i2) {
+                var libname = getString();
+                customSection.neededDynlibs.push(libname);
+            }
+        }
+        else {
+            failIf(name2 !== "dylink.0");
+            var WASM_DYLINK_MEM_INFO = 1;
+            var WASM_DYLINK_NEEDED = 2;
+            var WASM_DYLINK_EXPORT_INFO = 3;
+            var WASM_DYLINK_IMPORT_INFO = 4;
+            var WASM_SYMBOL_TLS = 256;
+            var WASM_SYMBOL_BINDING_MASK = 3;
+            var WASM_SYMBOL_BINDING_WEAK = 1;
+            while (offset < end) {
+                var subsectionType = getU8();
+                var subsectionSize = getLEB();
+                if (subsectionType === WASM_DYLINK_MEM_INFO) {
+                    customSection.memorySize = getLEB();
+                    customSection.memoryAlign = getLEB();
+                    customSection.tableSize = getLEB();
+                    customSection.tableAlign = getLEB();
+                }
+                else if (subsectionType === WASM_DYLINK_NEEDED) {
+                    var neededDynlibsCount = getLEB();
+                    for (var i2 = 0; i2 < neededDynlibsCount; ++i2) {
+                        libname = getString();
+                        customSection.neededDynlibs.push(libname);
+                    }
+                }
+                else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
+                    var count = getLEB();
+                    while (count--) {
+                        var symname = getString();
+                        var flags2 = getLEB();
+                        if (flags2 & WASM_SYMBOL_TLS) {
+                            customSection.tlsExports.add(symname);
+                        }
+                    }
+                }
+                else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {
+                    var count = getLEB();
+                    while (count--) {
+                        var modname = getString();
+                        var symname = getString();
+                        var flags2 = getLEB();
+                        if ((flags2 & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
+                            customSection.weakImports.add(symname);
+                        }
+                    }
+                }
+                else {
+                    offset += subsectionSize;
+                }
+            }
+        }
+        return customSection;
+    }, "getDylinkMetadata");
+    function getValue(ptr, type = "i8") {
+        if (type.endsWith("*"))
+            type = "*";
+        switch (type) {
+            case "i1":
+                return HEAP8[ptr];
+            case "i8":
+                return HEAP8[ptr];
+            case "i16":
+                return LE_HEAP_LOAD_I16((ptr >> 1) * 2);
+            case "i32":
+                return LE_HEAP_LOAD_I32((ptr >> 2) * 4);
+            case "i64":
+                return HEAP64[ptr >> 3];
+            case "float":
+                return LE_HEAP_LOAD_F32((ptr >> 2) * 4);
+            case "double":
+                return LE_HEAP_LOAD_F64((ptr >> 3) * 8);
+            case "*":
+                return LE_HEAP_LOAD_U32((ptr >> 2) * 4);
+            default:
+                abort(`invalid type for getValue: ${type}`);
+        }
+    }
+    __name(getValue, "getValue");
+    var newDSO = /* @__PURE__ */ __name((name2, handle2, syms) => {
+        var dso = {
+            refcount: Infinity,
+            name: name2,
+            exports: syms,
+            global: true,
+        };
+        LDSO.loadedLibsByName[name2] = dso;
+        if (handle2 != void 0) {
+            LDSO.loadedLibsByHandle[handle2] = dso;
+        }
+        return dso;
+    }, "newDSO");
+    var LDSO = {
+        loadedLibsByName: {},
+        loadedLibsByHandle: {},
+        init() {
+            newDSO("__main__", 0, wasmImports);
+        },
+    };
+    var ___heap_base = 78224;
+    var alignMemory = /* @__PURE__ */ __name((size, alignment) => Math.ceil(size / alignment) * alignment, "alignMemory");
+    var getMemory = /* @__PURE__ */ __name((size) => {
+        if (runtimeInitialized) {
+            return _calloc(size, 1);
+        }
+        var ret = ___heap_base;
+        var end = ret + alignMemory(size, 16);
+        ___heap_base = end(!GOT.__heap_base) && GOTHandler.get(wasmImports, "__heap_base");
+        GOT["__heap_base"].value = end;
+        return ret;
+    }, "getMemory");
+    var isInternalSym = /* @__PURE__ */ __name((symName) => ["__cpp_exception", "__c_longjmp", "__wasm_apply_data_relocs", "__dso_handle", "__tls_size", "__tls_align", "__set_stack_limits", "_emscripten_tls_init", "__wasm_init_tls", "__wasm_call_ctors", "__start_em_asm", "__stop_em_asm", "__start_em_js", "__stop_em_js"].includes(symName) || symName.startsWith("__em_js__"), "isInternalSym");
+    var uleb128Encode = /* @__PURE__ */ __name((n, target) => {
+        if (n < 128) {
+            target.push(n);
+        }
+        else {
+            target.push(n % 128 | 128, n >> 7);
+        }
+    }, "uleb128Encode");
+    var sigToWasmTypes = /* @__PURE__ */ __name((sig) => {
+        var typeNames = {
+            i: "i32",
+            j: "i64",
+            f: "f32",
+            d: "f64",
+            e: "externref",
+            p: "i32",
+        };
+        var type = {
+            parameters: [],
+            results: sig[0] == "v" ? [] : [typeNames[sig[0]]],
+        };
+        for (var i2 = 1; i2 < sig.length; ++i2) {
+            type.parameters.push(typeNames[sig[i2]]);
+        }
+        return type;
+    }, "sigToWasmTypes");
+    var generateFuncType = /* @__PURE__ */ __name((sig, target) => {
+        var sigRet = sig.slice(0, 1);
+        var sigParam = sig.slice(1);
+        var typeCodes = {
+            i: 127,
+            // i32
+            p: 127,
+            // i32
+            j: 126,
+            // i64
+            f: 125,
+            // f32
+            d: 124,
+            // f64
+            e: 111,
+        };
+        target.push(96);
+        uleb128Encode(sigParam.length, target);
+        for (var i2 = 0; i2 < sigParam.length; ++i2) {
+            target.push(typeCodes[sigParam[i2]]);
+        }
+        if (sigRet == "v") {
+            target.push(0);
+        }
+        else {
+            target.push(1, typeCodes[sigRet]);
+        }
+    }, "generateFuncType");
+    var convertJsFunctionToWasm = /* @__PURE__ */ __name((func2, sig) => {
+        if (typeof WebAssembly.Function == "function") {
+            return new WebAssembly.Function(sigToWasmTypes(sig), func2);
+        }
+        var typeSectionBody = [1];
+        generateFuncType(sig, typeSectionBody);
+        var bytes = [
+            0,
+            97,
+            115,
+            109,
+            // magic ("\0asm")
+            1,
+            0,
+            0,
+            0,
+            // version: 1
+            1,
+        ];
+        uleb128Encode(typeSectionBody.length, bytes);
+        bytes.push(...typeSectionBody);
+        bytes.push(2, 7, 
+        // import section
+        // (import "e" "f" (func 0 (type 0)))
+        1, 1, 101, 1, 102, 0, 0, 7, 5, 
+        // export section
+        // (export "f" (func 0 (type 0)))
+        1, 1, 102, 0, 0);
+        var module2 = new WebAssembly.Module(new Uint8Array(bytes));
+        var instance2 = new WebAssembly.Instance(module2, {
+            e: {
+                f: func2,
+            },
+        });
+        var wrappedFunc = instance2.exports["f"];
+        return wrappedFunc;
+    }, "convertJsFunctionToWasm");
+    var wasmTableMirror = [];
+    var wasmTable = new WebAssembly.Table({
+        initial: 31,
+        element: "anyfunc",
+    });
+    var getWasmTableEntry = /* @__PURE__ */ __name((funcPtr) => {
+        var func2 = wasmTableMirror[funcPtr];
+        if (!func2) {
+            if (funcPtr >= wasmTableMirror.length)
+                wasmTableMirror.length = funcPtr + 1;
+            wasmTableMirror[funcPtr] = func2 = wasmTable.get(funcPtr);
+        }
+        return func2;
+    }, "getWasmTableEntry");
+    var updateTableMap = /* @__PURE__ */ __name((offset, count) => {
+        if (functionsInTableMap) {
+            for (var i2 = offset; i2 < offset + count; i2++) {
+                var item = getWasmTableEntry(i2);
+                if (item) {
+                    functionsInTableMap.set(item, i2);
+                }
+            }
+        }
+    }, "updateTableMap");
+    var functionsInTableMap;
+    var getFunctionAddress = /* @__PURE__ */ __name((func2) => {
+        if (!functionsInTableMap) {
+            functionsInTableMap = /* @__PURE__ */ new WeakMap();
+            updateTableMap(0, wasmTable.length);
+        }
+        return functionsInTableMap.get(func2) || 0;
+    }, "getFunctionAddress");
+    var freeTableIndexes = [];
+    var getEmptyTableSlot = /* @__PURE__ */ __name(() => {
+        if (freeTableIndexes.length) {
+            return freeTableIndexes.pop();
+        }
+        try {
+            wasmTable.grow(1);
+        }
+        catch (err2) {
+            if (!(err2 instanceof RangeError)) {
+                throw err2;
+            }
+            throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
+        }
+        return wasmTable.length - 1;
+    }, "getEmptyTableSlot");
+    var setWasmTableEntry = /* @__PURE__ */ __name((idx, func2) => {
+        wasmTable.set(idx, func2);
+        wasmTableMirror[idx] = wasmTable.get(idx);
+    }, "setWasmTableEntry");
+    var addFunction = /* @__PURE__ */ __name((func2, sig) => {
+        var rtn = getFunctionAddress(func2);
+        if (rtn) {
+            return rtn;
+        }
+        var ret = getEmptyTableSlot();
+        try {
+            setWasmTableEntry(ret, func2);
+        }
+        catch (err2) {
+            if (!(err2 instanceof TypeError)) {
+                throw err2;
+            }
+            var wrapped = convertJsFunctionToWasm(func2, sig);
+            setWasmTableEntry(ret, wrapped);
+        }
+        functionsInTableMap.set(func2, ret);
+        return ret;
+    }, "addFunction");
+    var updateGOT = /* @__PURE__ */ __name((exports, replace) => {
+        for (var symName in exports) {
+            if (isInternalSym(symName)) {
+                continue;
+            }
+            var value = exports[symName];
+            GOT[symName] ||= new WebAssembly.Global({
+                value: "i32",
+                mutable: true,
+            });
+            if (replace || GOT[symName].value == 0) {
+                if (typeof value == "function") {
+                    GOT[symName].value = addFunction(value);
+                }
+                else if (typeof value == "number") {
+                    GOT[symName].value = value;
+                }
+                else {
+                    err(`unhandled export type for '${symName}': ${typeof value}`);
+                }
+            }
+        }
+    }, "updateGOT");
+    var relocateExports = /* @__PURE__ */ __name((exports, memoryBase2, replace) => {
+        var relocated = {};
+        for (var e in exports) {
+            var value = exports[e];
+            if (typeof value == "object") {
+                value = value.value;
+            }
+            if (typeof value == "number") {
+                value += memoryBase2;
+            }
+            relocated[e] = value;
+        }
+        updateGOT(relocated, replace);
+        return relocated;
+    }, "relocateExports");
+    var isSymbolDefined = /* @__PURE__ */ __name((symName) => {
+        var existing = wasmImports[symName];
+        if (!existing || existing.stub) {
+            return false;
+        }
+        return true;
+    }, "isSymbolDefined");
+    var dynCall = /* @__PURE__ */ __name((sig, ptr, args2 = []) => {
+        var rtn = getWasmTableEntry(ptr)(...args2);
+        return rtn;
+    }, "dynCall");
+    var stackSave = /* @__PURE__ */ __name(() => _emscripten_stack_get_current(), "stackSave");
+    var stackRestore = /* @__PURE__ */ __name((val) => __emscripten_stack_restore(val), "stackRestore");
+    var createInvokeFunction = /* @__PURE__ */ __name((sig) => (ptr, ...args2) => {
+        var sp = stackSave();
+        try {
+            return dynCall(sig, ptr, args2);
+        }
+        catch (e) {
+            stackRestore(sp);
+            if (e !== e + 0)
+                throw e;
+            _setThrew(1, 0);
+            if (sig[0] == "j")
+                return 0n;
+        }
+    }, "createInvokeFunction");
+    var resolveGlobalSymbol = /* @__PURE__ */ __name((symName, direct = false) => {
+        var sym;
+        if (isSymbolDefined(symName)) {
+            sym = wasmImports[symName];
+        }
+        else if (symName.startsWith("invoke_")) {
+            sym = wasmImports[symName] = createInvokeFunction(symName.split("_")[1]);
+        }
+        return {
+            sym,
+            name: symName,
+        };
+    }, "resolveGlobalSymbol");
+    var UTF8ToString = /* @__PURE__ */ __name((ptr, maxBytesToRead) => (ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""), "UTF8ToString");
+    var loadWebAssemblyModule = /* @__PURE__ */ __name((binary, flags, libName, localScope, handle) => {
+        var metadata = getDylinkMetadata(binary);
+        currentModuleWeakSymbols = metadata.weakImports;
+        function loadModule() {
+            var firstLoad = !handle || !HEAP8[handle + 8];
+            if (firstLoad) {
+                var memAlign = Math.pow(2, metadata.memoryAlign);
+                var memoryBase = metadata.memorySize ? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign) : 0;
+                var tableBase = metadata.tableSize ? wasmTable.length : 0;
+                if (handle) {
+                    HEAP8[handle + 8] = 1;
+                    LE_HEAP_STORE_U32(((handle + 12) >> 2) * 4, memoryBase);
+                    LE_HEAP_STORE_I32(((handle + 16) >> 2) * 4, metadata.memorySize);
+                    LE_HEAP_STORE_U32(((handle + 20) >> 2) * 4, tableBase);
+                    LE_HEAP_STORE_I32(((handle + 24) >> 2) * 4, metadata.tableSize);
+                }
+            }
+            else {
+                memoryBase = LE_HEAP_LOAD_U32(((handle + 12) >> 2) * 4);
+                tableBase = LE_HEAP_LOAD_U32(((handle + 20) >> 2) * 4);
+            }
+            var tableGrowthNeeded = tableBase + metadata.tableSize - wasmTable.length;
+            if (tableGrowthNeeded > 0) {
+                wasmTable.grow(tableGrowthNeeded);
+            }
+            var moduleExports;
+            function resolveSymbol(sym) {
+                var resolved = resolveGlobalSymbol(sym).sym;
+                if (!resolved && localScope) {
+                    resolved = localScope[sym];
+                }
+                if (!resolved) {
+                    resolved = moduleExports[sym];
+                }
+                return resolved;
+            }
+            __name(resolveSymbol, "resolveSymbol");
+            var proxyHandler = {
+                get(stubs, prop) {
+                    switch (prop) {
+                        case "__memory_base":
+                            return memoryBase;
+                        case "__table_base":
+                            return tableBase;
+                    }
+                    if (prop in wasmImports && !wasmImports[prop].stub) {
+                        return wasmImports[prop];
+                    }
+                    if (!(prop in stubs)) {
+                        var resolved;
+                        stubs[prop] = (...args2) => {
+                            resolved ||= resolveSymbol(prop);
+                            return resolved(...args2);
+                        };
+                    }
+                    return stubs[prop];
+                },
+            };
+            var proxy = new Proxy({}, proxyHandler);
+            var info = {
+                "GOT.mem": new Proxy({}, GOTHandler),
+                "GOT.func": new Proxy({}, GOTHandler),
+                env: proxy,
+                wasi_snapshot_preview1: proxy,
+            };
+            function postInstantiation(module, instance) {
+                updateTableMap(tableBase, metadata.tableSize);
+                moduleExports = relocateExports(instance.exports, memoryBase);
+                if (!flags.allowUndefined) {
+                    reportUndefinedSymbols();
+                }
+                function addEmAsm(addr, body) {
+                    var args = [];
+                    var arity = 0;
+                    for (; arity < 16; arity++) {
+                        if (body.indexOf("$" + arity) != -1) {
+                            args.push("$" + arity);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    args = args.join(",");
+                    var func = `(${args}) => { ${body} };`;
+                    ASM_CONSTS[start] = eval(func);
+                }
+                __name(addEmAsm, "addEmAsm");
+                if ("__start_em_asm" in moduleExports) {
+                    var start = moduleExports["__start_em_asm"];
+                    var stop = moduleExports["__stop_em_asm"];
+                    while (start < stop) {
+                        var jsString = UTF8ToString(start);
+                        addEmAsm(start, jsString);
+                        start = HEAPU8.indexOf(0, start) + 1;
+                    }
+                }
+                function addEmJs(name, cSig, body) {
+                    var jsArgs = [];
+                    cSig = cSig.slice(1, -1);
+                    if (cSig != "void") {
+                        cSig = cSig.split(",");
+                        for (var i in cSig) {
+                            var jsArg = cSig[i].split(" ").pop();
+                            jsArgs.push(jsArg.replace("*", ""));
+                        }
+                    }
+                    var func = `(${jsArgs}) => ${body};`;
+                    moduleExports[name] = eval(func);
+                }
+                __name(addEmJs, "addEmJs");
+                for (var name in moduleExports) {
+                    if (name.startsWith("__em_js__")) {
+                        var start = moduleExports[name];
+                        var jsString = UTF8ToString(start);
+                        var parts = jsString.split("<::>");
+                        addEmJs(name.replace("__em_js__", ""), parts[0], parts[1]);
+                        delete moduleExports[name];
+                    }
+                }
+                var applyRelocs = moduleExports["__wasm_apply_data_relocs"];
+                if (applyRelocs) {
+                    if (runtimeInitialized) {
+                        applyRelocs();
+                    }
+                    else {
+                        __RELOC_FUNCS__.push(applyRelocs);
+                    }
+                }
+                var init = moduleExports["__wasm_call_ctors"];
+                if (init) {
+                    if (runtimeInitialized) {
+                        init();
+                    }
+                    else {
+                        __ATINIT__.push(init);
+                    }
+                }
+                return moduleExports;
+            }
+            __name(postInstantiation, "postInstantiation");
+            if (flags.loadAsync) {
+                if (binary instanceof WebAssembly.Module) {
+                    var instance = new WebAssembly.Instance(binary, info);
+                    return Promise.resolve(postInstantiation(binary, instance));
+                }
+                return WebAssembly.instantiate(binary, info).then((result) => postInstantiation(result.module, result.instance));
+            }
+            var module = binary instanceof WebAssembly.Module ? binary : new WebAssembly.Module(binary);
+            var instance = new WebAssembly.Instance(module, info);
+            return postInstantiation(module, instance);
+        }
+        __name(loadModule, "loadModule");
+        if (flags.loadAsync) {
+            return metadata.neededDynlibs.reduce((chain, dynNeeded) => chain.then(() => loadDynamicLibrary(dynNeeded, flags, localScope)), Promise.resolve()).then(loadModule);
+        }
+        metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope));
+        return loadModule();
+    }, "loadWebAssemblyModule");
+    var mergeLibSymbols = /* @__PURE__ */ __name((exports, libName2) => {
+        for (var [sym, exp] of Object.entries(exports)) {
+            const setImport = /* @__PURE__ */ __name((target) => {
+                if (!isSymbolDefined(target)) {
+                    wasmImports[target] = exp;
+                }
+            }, "setImport");
+            setImport(sym);
+            const main_alias = "__main_argc_argv";
+            if (sym == "main") {
+                setImport(main_alias);
+            }
+            if (sym == main_alias) {
+                setImport("main");
+            }
+        }
+    }, "mergeLibSymbols");
+    var asyncLoad = /* @__PURE__ */ __name(async (url) => {
+        var arrayBuffer = await readAsync(url);
+        return new Uint8Array(arrayBuffer);
+    }, "asyncLoad");
+    function loadDynamicLibrary(libName2, flags2 = {
+        global: true,
+        nodelete: true,
+    }, localScope2, handle2) {
+        var dso = LDSO.loadedLibsByName[libName2];
+        if (dso) {
+            if (!flags2.global) {
+                if (localScope2) {
+                    Object.assign(localScope2, dso.exports);
+                }
+            }
+            else if (!dso.global) {
+                dso.global = true;
+                mergeLibSymbols(dso.exports, libName2);
+            }
+            if (flags2.nodelete && dso.refcount !== Infinity) {
+                dso.refcount = Infinity;
+            }
+            dso.refcount++;
+            if (handle2) {
+                LDSO.loadedLibsByHandle[handle2] = dso;
+            }
+            return flags2.loadAsync ? Promise.resolve(true) : true;
+        }
+        dso = newDSO(libName2, handle2, "loading");
+        dso.refcount = flags2.nodelete ? Infinity : 1;
+        dso.global = flags2.global;
+        function loadLibData() {
+            if (handle2) {
+                var data = LE_HEAP_LOAD_U32(((handle2 + 28) >> 2) * 4);
+                var dataSize = LE_HEAP_LOAD_U32(((handle2 + 32) >> 2) * 4);
+                if (data && dataSize) {
+                    var libData = HEAP8.slice(data, data + dataSize);
+                    return flags2.loadAsync ? Promise.resolve(libData) : libData;
+                }
+            }
+            var libFile = locateFile(libName2);
+            if (flags2.loadAsync) {
+                return asyncLoad(libFile);
+            }
+            if (!readBinary) {
+                throw new Error(`${libFile}: file not found, and synchronous loading of external files is not available`);
+            }
+            return readBinary(libFile);
+        }
+        __name(loadLibData, "loadLibData");
+        function getExports() {
+            if (flags2.loadAsync) {
+                return loadLibData().then((libData) => loadWebAssemblyModule(libData, flags2, libName2, localScope2, handle2));
+            }
+            return loadWebAssemblyModule(loadLibData(), flags2, libName2, localScope2, handle2);
+        }
+        __name(getExports, "getExports");
+        function moduleLoaded(exports) {
+            if (dso.global) {
+                mergeLibSymbols(exports, libName2);
+            }
+            else if (localScope2) {
+                Object.assign(localScope2, exports);
+            }
+            dso.exports = exports;
+        }
+        __name(moduleLoaded, "moduleLoaded");
+        if (flags2.loadAsync) {
+            return getExports().then((exports) => {
+                moduleLoaded(exports);
+                return true;
+            });
+        }
+        moduleLoaded(getExports());
+        return true;
+    }
+    __name(loadDynamicLibrary, "loadDynamicLibrary");
+    var reportUndefinedSymbols = /* @__PURE__ */ __name(() => {
+        for (var [symName, entry] of Object.entries(GOT)) {
+            if (entry.value == 0) {
+                var value = resolveGlobalSymbol(symName, true).sym;
+                if (!value && !entry.required) {
+                    continue;
+                }
+                if (typeof value == "function") {
+                    entry.value = addFunction(value, value.sig);
+                }
+                else if (typeof value == "number") {
+                    entry.value = value;
+                }
+                else {
+                    throw new Error(`bad export type for '${symName}': ${typeof value}`);
+                }
+            }
+        }
+    }, "reportUndefinedSymbols");
+    var loadDylibs = /* @__PURE__ */ __name(() => {
+        if (!dynamicLibraries.length) {
+            reportUndefinedSymbols();
+            return;
+        }
+        addRunDependency("loadDylibs");
+        dynamicLibraries
+            .reduce((chain, lib) => chain.then(() => loadDynamicLibrary(lib, {
+            loadAsync: true,
+            global: true,
+            nodelete: true,
+            allowUndefined: true,
+        })), Promise.resolve())
+            .then(() => {
+            reportUndefinedSymbols();
+            removeRunDependency("loadDylibs");
+        });
+    }, "loadDylibs");
+    function setValue(ptr, value, type = "i8") {
+        if (type.endsWith("*"))
+            type = "*";
+        switch (type) {
+            case "i1":
+                HEAP8[ptr] = value;
+                break;
+            case "i8":
+                HEAP8[ptr] = value;
+                break;
+            case "i16":
+                LE_HEAP_STORE_I16((ptr >> 1) * 2, value);
+                break;
+            case "i32":
+                LE_HEAP_STORE_I32((ptr >> 2) * 4, value);
+                break;
+            case "i64":
+                HEAP64[ptr >> 3] = BigInt(value);
+                break;
+            case "float":
+                LE_HEAP_STORE_F32((ptr >> 2) * 4, value);
+                break;
+            case "double":
+                LE_HEAP_STORE_F64((ptr >> 3) * 8, value);
+                break;
+            case "*":
+                LE_HEAP_STORE_U32((ptr >> 2) * 4, value);
+                break;
+            default:
+                abort(`invalid type for setValue: ${type}`);
+        }
+    }
+    __name(setValue, "setValue");
+    var ___memory_base = new WebAssembly.Global({
+        value: "i32",
+        mutable: false,
+    }, 1024);
+    var ___stack_pointer = new WebAssembly.Global({
+        value: "i32",
+        mutable: true,
+    }, 78224);
+    var ___table_base = new WebAssembly.Global({
+        value: "i32",
+        mutable: false,
+    }, 1);
+    var __abort_js = /* @__PURE__ */ __name(() => abort(""), "__abort_js");
+    __abort_js.sig = "v";
+    var _emscripten_get_now = /* @__PURE__ */ __name(() => performance.now(), "_emscripten_get_now");
+    _emscripten_get_now.sig = "d";
+    var _emscripten_date_now = /* @__PURE__ */ __name(() => Date.now(), "_emscripten_date_now");
+    _emscripten_date_now.sig = "d";
+    var nowIsMonotonic = 1;
+    var checkWasiClock = /* @__PURE__ */ __name((clock_id) => clock_id >= 0 && clock_id <= 3, "checkWasiClock");
+    var INT53_MAX = 9007199254740992;
+    var INT53_MIN = -9007199254740992;
+    var bigintToI53Checked = /* @__PURE__ */ __name((num) => (num < INT53_MIN || num > INT53_MAX ? NaN : Number(num)), "bigintToI53Checked");
+    function _clock_time_get(clk_id, ignored_precision, ptime) {
+        ignored_precision = bigintToI53Checked(ignored_precision);
+        if (!checkWasiClock(clk_id)) {
+            return 28;
+        }
+        var now;
+        if (clk_id === 0) {
+            now = _emscripten_date_now();
+        }
+        else if (nowIsMonotonic) {
+            now = _emscripten_get_now();
+        }
+        else {
+            return 52;
+        }
+        var nsec = Math.round(now * 1e3 * 1e3);
+        HEAP64[ptime >> 3] = BigInt(nsec);
+        return 0;
+    }
+    __name(_clock_time_get, "_clock_time_get");
+    _clock_time_get.sig = "iijp";
+    var getHeapMax = /* @__PURE__ */ __name(() => 
+    // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+    // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+    // for any code that deals with heap sizes, which would require special
+    // casing all heap size related code to treat 0 specially.
+    2147483648, "getHeapMax");
+    var growMemory = /* @__PURE__ */ __name((size) => {
+        var b = wasmMemory.buffer;
+        var pages = ((size - b.byteLength + 65535) / 65536) | 0;
+        try {
+            wasmMemory.grow(pages);
+            updateMemoryViews();
+            return 1;
+        }
+        catch (e) { }
+    }, "growMemory");
+    var _emscripten_resize_heap = /* @__PURE__ */ __name((requestedSize) => {
+        var oldSize = HEAPU8.length;
+        requestedSize >>>= 0;
+        var maxHeapSize = getHeapMax();
+        if (requestedSize > maxHeapSize) {
+            return false;
+        }
+        for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+            var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+            overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+            var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+            var replacement = growMemory(newSize);
+            if (replacement) {
+                return true;
+            }
+        }
+        return false;
+    }, "_emscripten_resize_heap");
+    _emscripten_resize_heap.sig = "ip";
+    var _fd_close = /* @__PURE__ */ __name((fd) => 52, "_fd_close");
+    _fd_close.sig = "ii";
+    function _fd_seek(fd, offset, whence, newOffset) {
+        offset = bigintToI53Checked(offset);
+        return 70;
+    }
+    __name(_fd_seek, "_fd_seek");
+    _fd_seek.sig = "iijip";
+    var printCharBuffers = [null, [], []];
+    var printChar = /* @__PURE__ */ __name((stream, curr) => {
+        var buffer = printCharBuffers[stream];
+        if (curr === 0 || curr === 10) {
+            ;
+            (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
+            buffer.length = 0;
+        }
+        else {
+            buffer.push(curr);
+        }
+    }, "printChar");
+    var flush_NO_FILESYSTEM = /* @__PURE__ */ __name(() => {
+        if (printCharBuffers[1].length)
+            printChar(1, 10);
+        if (printCharBuffers[2].length)
+            printChar(2, 10);
+    }, "flush_NO_FILESYSTEM");
+    var SYSCALLS = {
+        varargs: void 0,
+        getStr(ptr) {
+            var ret = UTF8ToString(ptr);
+            return ret;
+        },
+    };
+    var _fd_write = /* @__PURE__ */ __name((fd, iov, iovcnt, pnum) => {
+        var num = 0;
+        for (var i2 = 0; i2 < iovcnt; i2++) {
+            var ptr = LE_HEAP_LOAD_U32((iov >> 2) * 4);
+            var len = LE_HEAP_LOAD_U32(((iov + 4) >> 2) * 4);
+            iov += 8;
+            for (var j = 0; j < len; j++) {
+                printChar(fd, HEAPU8[ptr + j]);
+            }
+            num += len;
+        }
+        LE_HEAP_STORE_U32((pnum >> 2) * 4, num);
+        return 0;
+    }, "_fd_write");
+    _fd_write.sig = "iippp";
+    function _tree_sitter_log_callback(isLexMessage, messageAddress) {
+        if (Module.currentLogCallback) {
+            const message = UTF8ToString(messageAddress);
+            Module.currentLogCallback(message, isLexMessage !== 0);
+        }
+    }
+    __name(_tree_sitter_log_callback, "_tree_sitter_log_callback");
+    function _tree_sitter_parse_callback(inputBufferAddress, index, row, column, lengthAddress) {
+        const INPUT_BUFFER_SIZE = 10 * 1024;
+        const string = Module.currentParseCallback(index, {
+            row,
+            column,
+        });
+        if (typeof string === "string") {
+            setValue(lengthAddress, string.length, "i32");
+            stringToUTF16(string, inputBufferAddress, INPUT_BUFFER_SIZE);
+        }
+        else {
+            setValue(lengthAddress, 0, "i32");
+        }
+    }
+    __name(_tree_sitter_parse_callback, "_tree_sitter_parse_callback");
+    function _tree_sitter_progress_callback(currentOffset, hasError) {
+        if (Module.currentProgressCallback) {
+            return Module.currentProgressCallback({
+                currentOffset,
+                hasError,
+            });
+        }
+        return false;
+    }
+    __name(_tree_sitter_progress_callback, "_tree_sitter_progress_callback");
+    function _tree_sitter_query_progress_callback(currentOffset) {
+        if (Module.currentQueryProgressCallback) {
+            return Module.currentQueryProgressCallback({
+                currentOffset,
+            });
+        }
+        return false;
+    }
+    __name(_tree_sitter_query_progress_callback, "_tree_sitter_query_progress_callback");
+    var runtimeKeepaliveCounter = 0;
+    var keepRuntimeAlive = /* @__PURE__ */ __name(() => noExitRuntime || runtimeKeepaliveCounter > 0, "keepRuntimeAlive");
+    var _proc_exit = /* @__PURE__ */ __name((code) => {
+        EXITSTATUS = code;
+        if (!keepRuntimeAlive()) {
+            Module["onExit"]?.(code);
+            ABORT = true;
+        }
+        quit_(code, new ExitStatus(code));
+    }, "_proc_exit");
+    _proc_exit.sig = "vi";
+    var exitJS = /* @__PURE__ */ __name((status, implicit) => {
+        EXITSTATUS = status;
+        _proc_exit(status);
+    }, "exitJS");
+    var handleException = /* @__PURE__ */ __name((e) => {
+        if (e instanceof ExitStatus || e == "unwind") {
+            return EXITSTATUS;
+        }
+        quit_(1, e);
+    }, "handleException");
+    var lengthBytesUTF8 = /* @__PURE__ */ __name((str) => {
+        var len = 0;
+        for (var i2 = 0; i2 < str.length; ++i2) {
+            var c = str.charCodeAt(i2);
+            if (c <= 127) {
+                len++;
+            }
+            else if (c <= 2047) {
+                len += 2;
+            }
+            else if (c >= 55296 && c <= 57343) {
+                len += 4;
+                ++i2;
+            }
+            else {
+                len += 3;
+            }
+        }
+        return len;
+    }, "lengthBytesUTF8");
+    var stringToUTF8Array = /* @__PURE__ */ __name((str, heap, outIdx, maxBytesToWrite) => {
+        if (!(maxBytesToWrite > 0))
+            return 0;
+        var startIdx = outIdx;
+        var endIdx = outIdx + maxBytesToWrite - 1;
+        for (var i2 = 0; i2 < str.length; ++i2) {
+            var u = str.charCodeAt(i2);
+            if (u >= 55296 && u <= 57343) {
+                var u1 = str.charCodeAt(++i2);
+                u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
+            }
+            if (u <= 127) {
+                if (outIdx >= endIdx)
+                    break;
+                heap[outIdx++] = u;
+            }
+            else if (u <= 2047) {
+                if (outIdx + 1 >= endIdx)
+                    break;
+                heap[outIdx++] = 192 | (u >> 6);
+                heap[outIdx++] = 128 | (u & 63);
+            }
+            else if (u <= 65535) {
+                if (outIdx + 2 >= endIdx)
+                    break;
+                heap[outIdx++] = 224 | (u >> 12);
+                heap[outIdx++] = 128 | ((u >> 6) & 63);
+                heap[outIdx++] = 128 | (u & 63);
+            }
+            else {
+                if (outIdx + 3 >= endIdx)
+                    break;
+                heap[outIdx++] = 240 | (u >> 18);
+                heap[outIdx++] = 128 | ((u >> 12) & 63);
+                heap[outIdx++] = 128 | ((u >> 6) & 63);
+                heap[outIdx++] = 128 | (u & 63);
+            }
+        }
+        heap[outIdx] = 0;
+        return outIdx - startIdx;
+    }, "stringToUTF8Array");
+    var stringToUTF8 = /* @__PURE__ */ __name((str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite), "stringToUTF8");
+    var stackAlloc = /* @__PURE__ */ __name((sz) => __emscripten_stack_alloc(sz), "stackAlloc");
+    var stringToUTF8OnStack = /* @__PURE__ */ __name((str) => {
+        var size = lengthBytesUTF8(str) + 1;
+        var ret = stackAlloc(size);
+        stringToUTF8(str, ret, size);
+        return ret;
+    }, "stringToUTF8OnStack");
+    var AsciiToString = /* @__PURE__ */ __name((ptr) => {
+        var str = "";
+        while (1) {
+            var ch = HEAPU8[ptr++];
+            if (!ch)
+                return str;
+            str += String.fromCharCode(ch);
+        }
+    }, "AsciiToString");
+    var stringToUTF16 = /* @__PURE__ */ __name((str, outPtr, maxBytesToWrite) => {
+        maxBytesToWrite ??= 2147483647;
+        if (maxBytesToWrite < 2)
+            return 0;
+        maxBytesToWrite -= 2;
+        var startPtr = outPtr;
+        var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+        for (var i2 = 0; i2 < numCharsToWrite; ++i2) {
+            var codeUnit = str.charCodeAt(i2);
+            LE_HEAP_STORE_I16((outPtr >> 1) * 2, codeUnit);
+            outPtr += 2;
+        }
+        LE_HEAP_STORE_I16((outPtr >> 1) * 2, 0);
+        return outPtr - startPtr;
+    }, "stringToUTF16");
+    var wasmImports = {
+        /** @export */
+        __heap_base: ___heap_base,
+        /** @export */
+        __indirect_function_table: wasmTable,
+        /** @export */
+        __memory_base: ___memory_base,
+        /** @export */
+        __stack_pointer: ___stack_pointer,
+        /** @export */
+        __table_base: ___table_base,
+        /** @export */
+        _abort_js: __abort_js,
+        /** @export */
+        clock_time_get: _clock_time_get,
+        /** @export */
+        emscripten_resize_heap: _emscripten_resize_heap,
+        /** @export */
+        fd_close: _fd_close,
+        /** @export */
+        fd_seek: _fd_seek,
+        /** @export */
+        fd_write: _fd_write,
+        /** @export */
+        memory: wasmMemory,
+        /** @export */
+        tree_sitter_log_callback: _tree_sitter_log_callback,
+        /** @export */
+        tree_sitter_parse_callback: _tree_sitter_parse_callback,
+        /** @export */
+        tree_sitter_progress_callback: _tree_sitter_progress_callback,
+        /** @export */
+        tree_sitter_query_progress_callback: _tree_sitter_query_progress_callback,
+    };
+    // IMPORTANT
+    async function createWasm() {
+        addRunDependency("wasm-instantiate");
+        const info = {
+            env: wasmImports,
+            wasi_snapshot_preview1: wasmImports,
+            "GOT.mem": new Proxy(wasmImports, GOTHandler),
+            "GOT.func": new Proxy(wasmImports, GOTHandler),
+        };
+        // 
+        // try instantiate arg
+        // 
+        if (Module["instantiateWasm"]) {
+            try {
+                return Module["instantiateWasm"](info, receiveInstance);
+            }
+            catch (e) {
+                err(`Module.instantiateWasm callback failed with error: ${e}`);
+                readyPromiseReject(e);
+            }
+        }
+        // 
+        // get path (if missing)
+        // 
+        if (!wasmBinaryFilePath) {
+            const path = Module["defaultWasmPath"];
+            if (locateFile) {
+                if (!isDataURI(path)) {
+                    wasmBinaryFilePath = locateFile(path);
+                }
+                else {
+                    wasmBinaryFilePath = path;
+                }
+            }
+            else {
+                wasmBinaryFilePath = new URL(path, globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url).href;
+            }
+        }
+        // 
+        // instantiate module
+        // 
+        try {
+            let instantiationResult;
+            // 
+            // load wasm file
+            // 
+            const binaryFilePath = wasmBinaryFilePath;
+            const imports = info;
+            // 
+            // streaming
+            // 
+            if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFilePath) && isUrl(binaryFilePath) && !isFileURI(binaryFilePath) && fetch) {
+                try {
+                    var response = fetch(binaryFilePath, {
+                        credentials: "same-origin",
+                    });
+                    instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
+                }
+                catch (reason) {
+                    err(`wasm streaming compile failed: ${reason}`);
+                    err("falling back to ArrayBuffer instantiation");
+                }
+            }
+            // 
+            // fallback on non-streaming
+            // 
+            if (!instantiationResult) {
+                try {
+                    var binaryArray = wasmBinary;
+                    // 
+                    // get binary async
+                    // 
+                    if (!binaryArray) { // argument of main function
+                        try {
+                            binaryArray = new Uint8Array(await readAsync(binaryFilePath));
+                        }
+                        catch { }
+                    }
+                    // 
+                    // get binary sync
+                    // 
+                    if (!binaryArray) {
+                        if (binaryFilePath == wasmBinaryFilePath && wasmBinary) {
+                            binaryArray = new Uint8Array(wasmBinary);
+                        }
+                        else if (readBinary) {
+                            binaryArray = readBinary(binaryFilePath);
+                        }
+                        else {
+                            throw Error("both async and sync fetching of the wasm failed");
+                        }
+                    }
+                    // 
+                    // instantiate
+                    // 
+                    instantiationResult = await WebAssembly.instantiate(binaryArray, imports);
+                }
+                catch (reason) {
+                    err(`failed to asynchronously prepare wasm: ${reason}`);
+                    abort(reason);
+                }
+            }
+            instantiationResult = await instantiationResult;
+            return receiveInstance(instantiationResult["instance"], instantiationResult["module"]);
+        }
+        catch (e) {
+            readyPromiseReject(e);
+            return Promise.reject(e);
+        }
+        function receiveInstance(instance2, module2) {
+            wasmExports = instance2.exports;
+            wasmExports = relocateExports(wasmExports, 1024);
+            var metadata2 = getDylinkMetadata(module2);
+            if (metadata2.neededDynlibs) {
+                dynamicLibraries = metadata2.neededDynlibs.concat(dynamicLibraries);
+            }
+            mergeLibSymbols(wasmExports, "main");
+            LDSO.init();
+            loadDylibs();
+            addOnInit(wasmExports["__wasm_call_ctors"]);
+            __RELOC_FUNCS__.push(wasmExports["__wasm_apply_data_relocs"]);
+            removeRunDependency("wasm-instantiate");
+            return wasmExports;
+        }
+        __name(receiveInstance, "receiveInstance");
+    }
+    __name(createWasm, "createWasm");
+    var wasmExports = await createWasm();
+    var ___wasm_call_ctors = wasmExports["__wasm_call_ctors"];
+    var _malloc = (Module["_malloc"] = wasmExports["malloc"]);
+    var _calloc = (Module["_calloc"] = wasmExports["calloc"]);
+    var _realloc = (Module["_realloc"] = wasmExports["realloc"]);
+    var _free = (Module["_free"] = wasmExports["free"]);
+    var _memcmp = (Module["_memcmp"] = wasmExports["memcmp"]);
+    var _ts_language_symbol_count = (Module["_ts_language_symbol_count"] = wasmExports["ts_language_symbol_count"]);
+    var _ts_language_state_count = (Module["_ts_language_state_count"] = wasmExports["ts_language_state_count"]);
+    var _ts_language_version = (Module["_ts_language_version"] = wasmExports["ts_language_version"]);
+    var _ts_language_abi_version = (Module["_ts_language_abi_version"] = wasmExports["ts_language_abi_version"]);
+    var _ts_language_metadata = (Module["_ts_language_metadata"] = wasmExports["ts_language_metadata"]);
+    var _ts_language_name = (Module["_ts_language_name"] = wasmExports["ts_language_name"]);
+    var _ts_language_field_count = (Module["_ts_language_field_count"] = wasmExports["ts_language_field_count"]);
+    var _ts_language_next_state = (Module["_ts_language_next_state"] = wasmExports["ts_language_next_state"]);
+    var _ts_language_symbol_name = (Module["_ts_language_symbol_name"] = wasmExports["ts_language_symbol_name"]);
+    var _ts_language_symbol_for_name = (Module["_ts_language_symbol_for_name"] = wasmExports["ts_language_symbol_for_name"]);
+    var _strncmp = (Module["_strncmp"] = wasmExports["strncmp"]);
+    var _ts_language_symbol_type = (Module["_ts_language_symbol_type"] = wasmExports["ts_language_symbol_type"]);
+    var _ts_language_field_name_for_id = (Module["_ts_language_field_name_for_id"] = wasmExports["ts_language_field_name_for_id"]);
+    var _ts_lookahead_iterator_new = (Module["_ts_lookahead_iterator_new"] = wasmExports["ts_lookahead_iterator_new"]);
+    var _ts_lookahead_iterator_delete = (Module["_ts_lookahead_iterator_delete"] = wasmExports["ts_lookahead_iterator_delete"]);
+    var _ts_lookahead_iterator_reset_state = (Module["_ts_lookahead_iterator_reset_state"] = wasmExports["ts_lookahead_iterator_reset_state"]);
+    var _ts_lookahead_iterator_reset = (Module["_ts_lookahead_iterator_reset"] = wasmExports["ts_lookahead_iterator_reset"]);
+    var _ts_lookahead_iterator_next = (Module["_ts_lookahead_iterator_next"] = wasmExports["ts_lookahead_iterator_next"]);
+    var _ts_lookahead_iterator_current_symbol = (Module["_ts_lookahead_iterator_current_symbol"] = wasmExports["ts_lookahead_iterator_current_symbol"]);
+    var _ts_parser_delete = (Module["_ts_parser_delete"] = wasmExports["ts_parser_delete"]);
+    var _ts_parser_reset = (Module["_ts_parser_reset"] = wasmExports["ts_parser_reset"]);
+    var _ts_parser_set_language = (Module["_ts_parser_set_language"] = wasmExports["ts_parser_set_language"]);
+    var _ts_parser_timeout_micros = (Module["_ts_parser_timeout_micros"] = wasmExports["ts_parser_timeout_micros"]);
+    var _ts_parser_set_timeout_micros = (Module["_ts_parser_set_timeout_micros"] = wasmExports["ts_parser_set_timeout_micros"]);
+    var _ts_parser_set_included_ranges = (Module["_ts_parser_set_included_ranges"] = wasmExports["ts_parser_set_included_ranges"]);
+    var _ts_query_new = (Module["_ts_query_new"] = wasmExports["ts_query_new"]);
+    var _ts_query_delete = (Module["_ts_query_delete"] = wasmExports["ts_query_delete"]);
+    var _iswspace = (Module["_iswspace"] = wasmExports["iswspace"]);
+    var _iswalnum = (Module["_iswalnum"] = wasmExports["iswalnum"]);
+    var _ts_query_pattern_count = (Module["_ts_query_pattern_count"] = wasmExports["ts_query_pattern_count"]);
+    var _ts_query_capture_count = (Module["_ts_query_capture_count"] = wasmExports["ts_query_capture_count"]);
+    var _ts_query_string_count = (Module["_ts_query_string_count"] = wasmExports["ts_query_string_count"]);
+    var _ts_query_capture_name_for_id = (Module["_ts_query_capture_name_for_id"] = wasmExports["ts_query_capture_name_for_id"]);
+    var _ts_query_capture_quantifier_for_id = (Module["_ts_query_capture_quantifier_for_id"] = wasmExports["ts_query_capture_quantifier_for_id"]);
+    var _ts_query_string_value_for_id = (Module["_ts_query_string_value_for_id"] = wasmExports["ts_query_string_value_for_id"]);
+    var _ts_query_predicates_for_pattern = (Module["_ts_query_predicates_for_pattern"] = wasmExports["ts_query_predicates_for_pattern"]);
+    var _ts_query_start_byte_for_pattern = (Module["_ts_query_start_byte_for_pattern"] = wasmExports["ts_query_start_byte_for_pattern"]);
+    var _ts_query_end_byte_for_pattern = (Module["_ts_query_end_byte_for_pattern"] = wasmExports["ts_query_end_byte_for_pattern"]);
+    var _ts_query_is_pattern_rooted = (Module["_ts_query_is_pattern_rooted"] = wasmExports["ts_query_is_pattern_rooted"]);
+    var _ts_query_is_pattern_non_local = (Module["_ts_query_is_pattern_non_local"] = wasmExports["ts_query_is_pattern_non_local"]);
+    var _ts_query_is_pattern_guaranteed_at_step = (Module["_ts_query_is_pattern_guaranteed_at_step"] = wasmExports["ts_query_is_pattern_guaranteed_at_step"]);
+    var _ts_query_disable_capture = (Module["_ts_query_disable_capture"] = wasmExports["ts_query_disable_capture"]);
+    var _ts_query_disable_pattern = (Module["_ts_query_disable_pattern"] = wasmExports["ts_query_disable_pattern"]);
+    var _ts_tree_copy = (Module["_ts_tree_copy"] = wasmExports["ts_tree_copy"]);
+    var _ts_tree_delete = (Module["_ts_tree_delete"] = wasmExports["ts_tree_delete"]);
+    var _ts_init = (Module["_ts_init"] = wasmExports["ts_init"]);
+    var _ts_parser_new_wasm = (Module["_ts_parser_new_wasm"] = wasmExports["ts_parser_new_wasm"]);
+    var _ts_parser_enable_logger_wasm = (Module["_ts_parser_enable_logger_wasm"] = wasmExports["ts_parser_enable_logger_wasm"]);
+    var _ts_parser_parse_wasm = (Module["_ts_parser_parse_wasm"] = wasmExports["ts_parser_parse_wasm"]);
+    var _ts_parser_included_ranges_wasm = (Module["_ts_parser_included_ranges_wasm"] = wasmExports["ts_parser_included_ranges_wasm"]);
+    var _ts_language_type_is_named_wasm = (Module["_ts_language_type_is_named_wasm"] = wasmExports["ts_language_type_is_named_wasm"]);
+    var _ts_language_type_is_visible_wasm = (Module["_ts_language_type_is_visible_wasm"] = wasmExports["ts_language_type_is_visible_wasm"]);
+    var _ts_language_supertypes_wasm = (Module["_ts_language_supertypes_wasm"] = wasmExports["ts_language_supertypes_wasm"]);
+    var _ts_language_subtypes_wasm = (Module["_ts_language_subtypes_wasm"] = wasmExports["ts_language_subtypes_wasm"]);
+    var _ts_tree_root_node_wasm = (Module["_ts_tree_root_node_wasm"] = wasmExports["ts_tree_root_node_wasm"]);
+    var _ts_tree_root_node_with_offset_wasm = (Module["_ts_tree_root_node_with_offset_wasm"] = wasmExports["ts_tree_root_node_with_offset_wasm"]);
+    var _ts_tree_edit_wasm = (Module["_ts_tree_edit_wasm"] = wasmExports["ts_tree_edit_wasm"]);
+    var _ts_tree_included_ranges_wasm = (Module["_ts_tree_included_ranges_wasm"] = wasmExports["ts_tree_included_ranges_wasm"]);
+    var _ts_tree_get_changed_ranges_wasm = (Module["_ts_tree_get_changed_ranges_wasm"] = wasmExports["ts_tree_get_changed_ranges_wasm"]);
+    var _ts_tree_cursor_new_wasm = (Module["_ts_tree_cursor_new_wasm"] = wasmExports["ts_tree_cursor_new_wasm"]);
+    var _ts_tree_cursor_copy_wasm = (Module["_ts_tree_cursor_copy_wasm"] = wasmExports["ts_tree_cursor_copy_wasm"]);
+    var _ts_tree_cursor_delete_wasm = (Module["_ts_tree_cursor_delete_wasm"] = wasmExports["ts_tree_cursor_delete_wasm"]);
+    var _ts_tree_cursor_reset_wasm = (Module["_ts_tree_cursor_reset_wasm"] = wasmExports["ts_tree_cursor_reset_wasm"]);
+    var _ts_tree_cursor_reset_to_wasm = (Module["_ts_tree_cursor_reset_to_wasm"] = wasmExports["ts_tree_cursor_reset_to_wasm"]);
+    var _ts_tree_cursor_goto_first_child_wasm = (Module["_ts_tree_cursor_goto_first_child_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_wasm"]);
+    var _ts_tree_cursor_goto_last_child_wasm = (Module["_ts_tree_cursor_goto_last_child_wasm"] = wasmExports["ts_tree_cursor_goto_last_child_wasm"]);
+    var _ts_tree_cursor_goto_first_child_for_index_wasm = (Module["_ts_tree_cursor_goto_first_child_for_index_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_for_index_wasm"]);
+    var _ts_tree_cursor_goto_first_child_for_position_wasm = (Module["_ts_tree_cursor_goto_first_child_for_position_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_for_position_wasm"]);
+    var _ts_tree_cursor_goto_next_sibling_wasm = (Module["_ts_tree_cursor_goto_next_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_next_sibling_wasm"]);
+    var _ts_tree_cursor_goto_previous_sibling_wasm = (Module["_ts_tree_cursor_goto_previous_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_previous_sibling_wasm"]);
+    var _ts_tree_cursor_goto_descendant_wasm = (Module["_ts_tree_cursor_goto_descendant_wasm"] = wasmExports["ts_tree_cursor_goto_descendant_wasm"]);
+    var _ts_tree_cursor_goto_parent_wasm = (Module["_ts_tree_cursor_goto_parent_wasm"] = wasmExports["ts_tree_cursor_goto_parent_wasm"]);
+    var _ts_tree_cursor_current_node_type_id_wasm = (Module["_ts_tree_cursor_current_node_type_id_wasm"] = wasmExports["ts_tree_cursor_current_node_type_id_wasm"]);
+    var _ts_tree_cursor_current_node_state_id_wasm = (Module["_ts_tree_cursor_current_node_state_id_wasm"] = wasmExports["ts_tree_cursor_current_node_state_id_wasm"]);
+    var _ts_tree_cursor_current_node_is_named_wasm = (Module["_ts_tree_cursor_current_node_is_named_wasm"] = wasmExports["ts_tree_cursor_current_node_is_named_wasm"]);
+    var _ts_tree_cursor_current_node_is_missing_wasm = (Module["_ts_tree_cursor_current_node_is_missing_wasm"] = wasmExports["ts_tree_cursor_current_node_is_missing_wasm"]);
+    var _ts_tree_cursor_current_node_id_wasm = (Module["_ts_tree_cursor_current_node_id_wasm"] = wasmExports["ts_tree_cursor_current_node_id_wasm"]);
+    var _ts_tree_cursor_start_position_wasm = (Module["_ts_tree_cursor_start_position_wasm"] = wasmExports["ts_tree_cursor_start_position_wasm"]);
+    var _ts_tree_cursor_end_position_wasm = (Module["_ts_tree_cursor_end_position_wasm"] = wasmExports["ts_tree_cursor_end_position_wasm"]);
+    var _ts_tree_cursor_start_index_wasm = (Module["_ts_tree_cursor_start_index_wasm"] = wasmExports["ts_tree_cursor_start_index_wasm"]);
+    var _ts_tree_cursor_end_index_wasm = (Module["_ts_tree_cursor_end_index_wasm"] = wasmExports["ts_tree_cursor_end_index_wasm"]);
+    var _ts_tree_cursor_current_field_id_wasm = (Module["_ts_tree_cursor_current_field_id_wasm"] = wasmExports["ts_tree_cursor_current_field_id_wasm"]);
+    var _ts_tree_cursor_current_depth_wasm = (Module["_ts_tree_cursor_current_depth_wasm"] = wasmExports["ts_tree_cursor_current_depth_wasm"]);
+    var _ts_tree_cursor_current_descendant_index_wasm = (Module["_ts_tree_cursor_current_descendant_index_wasm"] = wasmExports["ts_tree_cursor_current_descendant_index_wasm"]);
+    var _ts_tree_cursor_current_node_wasm = (Module["_ts_tree_cursor_current_node_wasm"] = wasmExports["ts_tree_cursor_current_node_wasm"]);
+    var _ts_node_symbol_wasm = (Module["_ts_node_symbol_wasm"] = wasmExports["ts_node_symbol_wasm"]);
+    var _ts_node_field_name_for_child_wasm = (Module["_ts_node_field_name_for_child_wasm"] = wasmExports["ts_node_field_name_for_child_wasm"]);
+    var _ts_node_field_name_for_named_child_wasm = (Module["_ts_node_field_name_for_named_child_wasm"] = wasmExports["ts_node_field_name_for_named_child_wasm"]);
+    var _ts_node_children_by_field_id_wasm = (Module["_ts_node_children_by_field_id_wasm"] = wasmExports["ts_node_children_by_field_id_wasm"]);
+    var _ts_node_first_child_for_byte_wasm = (Module["_ts_node_first_child_for_byte_wasm"] = wasmExports["ts_node_first_child_for_byte_wasm"]);
+    var _ts_node_first_named_child_for_byte_wasm = (Module["_ts_node_first_named_child_for_byte_wasm"] = wasmExports["ts_node_first_named_child_for_byte_wasm"]);
+    var _ts_node_grammar_symbol_wasm = (Module["_ts_node_grammar_symbol_wasm"] = wasmExports["ts_node_grammar_symbol_wasm"]);
+    var _ts_node_child_count_wasm = (Module["_ts_node_child_count_wasm"] = wasmExports["ts_node_child_count_wasm"]);
+    var _ts_node_named_child_count_wasm = (Module["_ts_node_named_child_count_wasm"] = wasmExports["ts_node_named_child_count_wasm"]);
+    var _ts_node_child_wasm = (Module["_ts_node_child_wasm"] = wasmExports["ts_node_child_wasm"]);
+    var _ts_node_named_child_wasm = (Module["_ts_node_named_child_wasm"] = wasmExports["ts_node_named_child_wasm"]);
+    var _ts_node_child_by_field_id_wasm = (Module["_ts_node_child_by_field_id_wasm"] = wasmExports["ts_node_child_by_field_id_wasm"]);
+    var _ts_node_next_sibling_wasm = (Module["_ts_node_next_sibling_wasm"] = wasmExports["ts_node_next_sibling_wasm"]);
+    var _ts_node_prev_sibling_wasm = (Module["_ts_node_prev_sibling_wasm"] = wasmExports["ts_node_prev_sibling_wasm"]);
+    var _ts_node_next_named_sibling_wasm = (Module["_ts_node_next_named_sibling_wasm"] = wasmExports["ts_node_next_named_sibling_wasm"]);
+    var _ts_node_prev_named_sibling_wasm = (Module["_ts_node_prev_named_sibling_wasm"] = wasmExports["ts_node_prev_named_sibling_wasm"]);
+    var _ts_node_descendant_count_wasm = (Module["_ts_node_descendant_count_wasm"] = wasmExports["ts_node_descendant_count_wasm"]);
+    var _ts_node_parent_wasm = (Module["_ts_node_parent_wasm"] = wasmExports["ts_node_parent_wasm"]);
+    var _ts_node_child_with_descendant_wasm = (Module["_ts_node_child_with_descendant_wasm"] = wasmExports["ts_node_child_with_descendant_wasm"]);
+    var _ts_node_descendant_for_index_wasm = (Module["_ts_node_descendant_for_index_wasm"] = wasmExports["ts_node_descendant_for_index_wasm"]);
+    var _ts_node_named_descendant_for_index_wasm = (Module["_ts_node_named_descendant_for_index_wasm"] = wasmExports["ts_node_named_descendant_for_index_wasm"]);
+    var _ts_node_descendant_for_position_wasm = (Module["_ts_node_descendant_for_position_wasm"] = wasmExports["ts_node_descendant_for_position_wasm"]);
+    var _ts_node_named_descendant_for_position_wasm = (Module["_ts_node_named_descendant_for_position_wasm"] = wasmExports["ts_node_named_descendant_for_position_wasm"]);
+    var _ts_node_start_point_wasm = (Module["_ts_node_start_point_wasm"] = wasmExports["ts_node_start_point_wasm"]);
+    var _ts_node_end_point_wasm = (Module["_ts_node_end_point_wasm"] = wasmExports["ts_node_end_point_wasm"]);
+    var _ts_node_start_index_wasm = (Module["_ts_node_start_index_wasm"] = wasmExports["ts_node_start_index_wasm"]);
+    var _ts_node_end_index_wasm = (Module["_ts_node_end_index_wasm"] = wasmExports["ts_node_end_index_wasm"]);
+    var _ts_node_to_string_wasm = (Module["_ts_node_to_string_wasm"] = wasmExports["ts_node_to_string_wasm"]);
+    var _ts_node_children_wasm = (Module["_ts_node_children_wasm"] = wasmExports["ts_node_children_wasm"]);
+    var _ts_node_named_children_wasm = (Module["_ts_node_named_children_wasm"] = wasmExports["ts_node_named_children_wasm"]);
+    var _ts_node_descendants_of_type_wasm = (Module["_ts_node_descendants_of_type_wasm"] = wasmExports["ts_node_descendants_of_type_wasm"]);
+    var _ts_node_is_named_wasm = (Module["_ts_node_is_named_wasm"] = wasmExports["ts_node_is_named_wasm"]);
+    var _ts_node_has_changes_wasm = (Module["_ts_node_has_changes_wasm"] = wasmExports["ts_node_has_changes_wasm"]);
+    var _ts_node_has_error_wasm = (Module["_ts_node_has_error_wasm"] = wasmExports["ts_node_has_error_wasm"]);
+    var _ts_node_is_error_wasm = (Module["_ts_node_is_error_wasm"] = wasmExports["ts_node_is_error_wasm"]);
+    var _ts_node_is_missing_wasm = (Module["_ts_node_is_missing_wasm"] = wasmExports["ts_node_is_missing_wasm"]);
+    var _ts_node_is_extra_wasm = (Module["_ts_node_is_extra_wasm"] = wasmExports["ts_node_is_extra_wasm"]);
+    var _ts_node_parse_state_wasm = (Module["_ts_node_parse_state_wasm"] = wasmExports["ts_node_parse_state_wasm"]);
+    var _ts_node_next_parse_state_wasm = (Module["_ts_node_next_parse_state_wasm"] = wasmExports["ts_node_next_parse_state_wasm"]);
+    var _ts_query_matches_wasm = (Module["_ts_query_matches_wasm"] = wasmExports["ts_query_matches_wasm"]);
+    var _ts_query_captures_wasm = (Module["_ts_query_captures_wasm"] = wasmExports["ts_query_captures_wasm"]);
+    var _memset = (Module["_memset"] = wasmExports["memset"]);
+    var _memcpy = (Module["_memcpy"] = wasmExports["memcpy"]);
+    var _memmove = (Module["_memmove"] = wasmExports["memmove"]);
+    var _iswalpha = (Module["_iswalpha"] = wasmExports["iswalpha"]);
+    var _iswblank = (Module["_iswblank"] = wasmExports["iswblank"]);
+    var _iswdigit = (Module["_iswdigit"] = wasmExports["iswdigit"]);
+    var _iswlower = (Module["_iswlower"] = wasmExports["iswlower"]);
+    var _iswupper = (Module["_iswupper"] = wasmExports["iswupper"]);
+    var _iswxdigit = (Module["_iswxdigit"] = wasmExports["iswxdigit"]);
+    var _memchr = (Module["_memchr"] = wasmExports["memchr"]);
+    var _strlen = (Module["_strlen"] = wasmExports["strlen"]);
+    var _strcmp = (Module["_strcmp"] = wasmExports["strcmp"]);
+    var _strncat = (Module["_strncat"] = wasmExports["strncat"]);
+    var _strncpy = (Module["_strncpy"] = wasmExports["strncpy"]);
+    var _towlower = (Module["_towlower"] = wasmExports["towlower"]);
+    var _towupper = (Module["_towupper"] = wasmExports["towupper"]);
+    var _setThrew = wasmExports["setThrew"];
+    var __emscripten_stack_restore = wasmExports["_emscripten_stack_restore"];
+    var __emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"];
+    var _emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"];
+    var ___wasm_apply_data_relocs = wasmExports["__wasm_apply_data_relocs"];
+    Module["setValue"] = setValue;
+    Module["getValue"] = getValue;
+    Module["UTF8ToString"] = UTF8ToString;
+    Module["stringToUTF8"] = stringToUTF8;
+    Module["lengthBytesUTF8"] = lengthBytesUTF8;
+    Module["AsciiToString"] = AsciiToString;
+    Module["stringToUTF16"] = stringToUTF16;
+    Module["loadWebAssemblyModule"] = loadWebAssemblyModule;
+    function callMain(args2 = []) {
+        var entryFunction = resolveGlobalSymbol("main").sym;
+        if (!entryFunction)
+            return;
+        args2.unshift(thisProgram);
+        var argc = args2.length;
+        var argv = stackAlloc((argc + 1) * 4);
+        var argv_ptr = argv;
+        args2.forEach((arg) => {
+            LE_HEAP_STORE_U32((argv_ptr >> 2) * 4, stringToUTF8OnStack(arg));
+            argv_ptr += 4;
+        });
+        LE_HEAP_STORE_U32((argv_ptr >> 2) * 4, 0);
+        try {
+            var ret = entryFunction(argc, argv);
+            exitJS(ret, 
+            /* implicit = */
+            true);
+            return ret;
+        }
+        catch (e) {
+            return handleException(e);
+        }
+    }
+    __name(callMain, "callMain");
+    function run(args2 = arguments_) {
+        if (runDependencies > 0) {
+            dependenciesFulfilled = run;
+            return;
+        }
+        preRun();
+        if (runDependencies > 0) {
+            dependenciesFulfilled = run;
+            return;
+        }
+        function doRun() {
+            Module["calledRun"] = true;
+            if (ABORT)
+                return;
+            initRuntime();
+            preMain();
+            readyPromiseResolve(Module);
+            Module["onRuntimeInitialized"]?.();
+            if (!Module["noInitialRun"])
+                callMain(args2);
+            postRun();
+        }
+        __name(doRun, "doRun");
+        if (Module["setStatus"]) {
+            Module["setStatus"]("Running...");
+            setTimeout(() => {
+                setTimeout(() => Module["setStatus"](""), 1);
+                doRun();
+            }, 1);
+        }
+        else {
+            doRun();
+        }
+    }
+    __name(run, "run");
+    if (Module["preInit"]) {
+        if (typeof Module["preInit"] == "function")
+            Module["preInit"] = [Module["preInit"]];
+        while (Module["preInit"].length > 0) {
+            Module["preInit"].pop()();
+        }
+    }
+    run();
+    return readyPromise;
+}