@qwen-code/qwen-code 0.19.9 → 0.19.10

package/chunks/tree-sitter-YJVE2ZUK.js

@@ -0,0 +1,2980 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  __qwen_dirname,
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __commonJS,
+  __name,
+  __require
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/web-tree-sitter/tree-sitter.js
+var require_tree_sitter = __commonJS({
+  "node_modules/web-tree-sitter/tree-sitter.js"(exports, module) {
+    init_esbuild_shims();
+    var Module = typeof Module != "undefined" ? Module : {};
+    var ENVIRONMENT_IS_WEB = typeof window == "object";
+    var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
+    var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
+    if (ENVIRONMENT_IS_NODE) {
+    }
+    var TreeSitter = function() {
+      var initPromise;
+      var document = typeof window == "object" ? {
+        currentScript: window.document.currentScript
+      } : null;
+      class Parser {
+        static {
+          __name(this, "Parser");
+        }
+        constructor() {
+          this.initialize();
+        }
+        initialize() {
+          throw new Error("cannot construct a Parser before calling `init()`");
+        }
+        static init(moduleOptions) {
+          if (initPromise) return initPromise;
+          Module = Object.assign({}, Module, moduleOptions);
+          return initPromise = new Promise((resolveInitPromise) => {
+            var moduleOverrides = Object.assign({}, Module);
+            var arguments_ = [];
+            var thisProgram = "./this.program";
+            var quit_ = /* @__PURE__ */ __name((status, toThrow) => {
+              throw toThrow;
+            }, "quit_");
+            var scriptDirectory = "";
+            function locateFile(path) {
+              if (Module["locateFile"]) {
+                return Module["locateFile"](path, scriptDirectory);
+              }
+              return scriptDirectory + path;
+            }
+            __name(locateFile, "locateFile");
+            var readAsync, readBinary;
+            if (ENVIRONMENT_IS_NODE) {
+              var fs = __require("fs");
+              var nodePath = __require("path");
+              scriptDirectory = __qwen_dirname + "/";
+              readBinary = /* @__PURE__ */ __name((filename) => {
+                filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+                var ret = fs.readFileSync(filename);
+                return ret;
+              }, "readBinary");
+              readAsync = /* @__PURE__ */ __name((filename, binary2 = true) => {
+                filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+                return new Promise((resolve, reject) => {
+                  fs.readFile(filename, binary2 ? void 0 : "utf8", (err2, data) => {
+                    if (err2) reject(err2);
+                    else resolve(binary2 ? data.buffer : data);
+                  });
+                });
+              }, "readAsync");
+              if (!Module["thisProgram"] && process.argv.length > 1) {
+                thisProgram = process.argv[1].replace(/\\/g, "/");
+              }
+              arguments_ = process.argv.slice(2);
+              if (typeof module != "undefined") {
+                module["exports"] = Module;
+              }
+              quit_ = /* @__PURE__ */ __name((status, toThrow) => {
+                process.exitCode = status;
+                throw toThrow;
+              }, "quit_");
+            } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+              if (ENVIRONMENT_IS_WORKER) {
+                scriptDirectory = self.location.href;
+              } else if (typeof document != "undefined" && document.currentScript) {
+                scriptDirectory = document.currentScript.src;
+              }
+              if (scriptDirectory.startsWith("blob:")) {
+                scriptDirectory = "";
+              } else {
+                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
+              }
+              {
+                if (ENVIRONMENT_IS_WORKER) {
+                  readBinary = /* @__PURE__ */ __name((url) => {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open("GET", url, false);
+                    xhr.responseType = "arraybuffer";
+                    xhr.send(null);
+                    return new Uint8Array(
+                      /** @type{!ArrayBuffer} */
+                      xhr.response
+                    );
+                  }, "readBinary");
+                }
+                readAsync = /* @__PURE__ */ __name((url) => {
+                  if (isFileURI(url)) {
+                    return new Promise((reject, resolve) => {
+                      var xhr = new XMLHttpRequest();
+                      xhr.open("GET", url, true);
+                      xhr.responseType = "arraybuffer";
+                      xhr.onload = () => {
+                        if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+                          resolve(xhr.response);
+                        }
+                        reject(xhr.status);
+                      };
+                      xhr.onerror = reject;
+                      xhr.send(null);
+                    });
+                  }
+                  return fetch(url, {
+                    credentials: "same-origin"
+                  }).then((response) => {
+                    if (response.ok) {
+                      return response.arrayBuffer();
+                    }
+                    return Promise.reject(new Error(response.status + " : " + response.url));
+                  });
+                }, "readAsync");
+              }
+            } else {
+            }
+            var out = Module["print"] || console.log.bind(console);
+            var err = Module["printErr"] || console.error.bind(console);
+            Object.assign(Module, moduleOverrides);
+            moduleOverrides = null;
+            if (Module["arguments"]) arguments_ = Module["arguments"];
+            if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+            if (Module["quit"]) quit_ = Module["quit"];
+            var dynamicLibraries = Module["dynamicLibraries"] || [];
+            var wasmBinary;
+            if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+            var wasmMemory;
+            var ABORT = false;
+            var EXITSTATUS;
+            var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+            var HEAP_DATA_VIEW;
+            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);
+            }
+            __name(updateMemoryViews, "updateMemoryViews");
+            if (Module["wasmMemory"]) {
+              wasmMemory = Module["wasmMemory"];
+            } else {
+              var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 33554432;
+              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": 2147483648 / 65536
+              });
+            }
+            updateMemoryViews();
+            var __ATPRERUN__ = [];
+            var __ATINIT__ = [];
+            var __ATMAIN__ = [];
+            var __ATPOSTRUN__ = [];
+            var __RELOC_FUNCS__ = [];
+            var runtimeInitialized = false;
+            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 addOnPostRun(cb) {
+              __ATPOSTRUN__.unshift(cb);
+            }
+            __name(addOnPostRun, "addOnPostRun");
+            var runDependencies = 0;
+            var runDependencyWatcher = null;
+            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 (runDependencyWatcher !== null) {
+                  clearInterval(runDependencyWatcher);
+                  runDependencyWatcher = null;
+                }
+                if (dependenciesFulfilled) {
+                  var callback = dependenciesFulfilled;
+                  dependenciesFulfilled = null;
+                  callback();
+                }
+              }
+            }
+            __name(removeRunDependency, "removeRunDependency");
+            function abort(what) {
+              Module["onAbort"]?.(what);
+              what = "Aborted(" + what + ")";
+              err(what);
+              ABORT = true;
+              EXITSTATUS = 1;
+              what += ". Build with -sASSERTIONS for more info.";
+              var e = new WebAssembly.RuntimeError(what);
+              throw e;
+            }
+            __name(abort, "abort");
+            var dataURIPrefix = "data:application/octet-stream;base64,";
+            var isDataURI = /* @__PURE__ */ __name((filename) => filename.startsWith(dataURIPrefix), "isDataURI");
+            var isFileURI = /* @__PURE__ */ __name((filename) => filename.startsWith("file://"), "isFileURI");
+            function findWasmBinary() {
+              var f = "tree-sitter.wasm";
+              if (!isDataURI(f)) {
+                return locateFile(f);
+              }
+              return f;
+            }
+            __name(findWasmBinary, "findWasmBinary");
+            var wasmBinaryFile;
+            function getBinarySync(file) {
+              if (file == wasmBinaryFile && wasmBinary) {
+                return new Uint8Array(wasmBinary);
+              }
+              if (readBinary) {
+                return readBinary(file);
+              }
+              throw "both async and sync fetching of the wasm failed";
+            }
+            __name(getBinarySync, "getBinarySync");
+            function getBinaryPromise(binaryFile) {
+              if (!wasmBinary) {
+                return readAsync(binaryFile).then(
+                  (response) => new Uint8Array(
+                    /** @type{!ArrayBuffer} */
+                    response
+                  ),
+                  // Fall back to getBinarySync if readAsync fails
+                  () => getBinarySync(binaryFile)
+                );
+              }
+              return Promise.resolve().then(() => getBinarySync(binaryFile));
+            }
+            __name(getBinaryPromise, "getBinaryPromise");
+            function instantiateArrayBuffer(binaryFile, imports, receiver) {
+              return getBinaryPromise(binaryFile).then((binary2) => WebAssembly.instantiate(binary2, imports)).then(receiver, (reason) => {
+                err(`failed to asynchronously prepare wasm: ${reason}`);
+                abort(reason);
+              });
+            }
+            __name(instantiateArrayBuffer, "instantiateArrayBuffer");
+            function instantiateAsync(binary2, binaryFile, imports, callback) {
+              if (!binary2 && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
+              !isFileURI(binaryFile) && // Avoid instantiateStreaming() on Node.js environment for now, as while
+              // Node.js v18.1.0 implements it, it does not have a full fetch()
+              // implementation yet.
+              // Reference:
+              //   https://github.com/emscripten-core/emscripten/pull/16917
+              !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
+                return fetch(binaryFile, {
+                  credentials: "same-origin"
+                }).then((response) => {
+                  var result = WebAssembly.instantiateStreaming(response, imports);
+                  return result.then(callback, function(reason) {
+                    err(`wasm streaming compile failed: ${reason}`);
+                    err("falling back to ArrayBuffer instantiation");
+                    return instantiateArrayBuffer(binaryFile, imports, callback);
+                  });
+                });
+              }
+              return instantiateArrayBuffer(binaryFile, imports, callback);
+            }
+            __name(instantiateAsync, "instantiateAsync");
+            function getWasmImports() {
+              return {
+                "env": wasmImports,
+                "wasi_snapshot_preview1": wasmImports,
+                "GOT.mem": new Proxy(wasmImports, GOTHandler),
+                "GOT.func": new Proxy(wasmImports, GOTHandler)
+              };
+            }
+            __name(getWasmImports, "getWasmImports");
+            function createWasm() {
+              var info2 = getWasmImports();
+              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");
+              addRunDependency("wasm-instantiate");
+              function receiveInstantiationResult(result) {
+                receiveInstance(result["instance"], result["module"]);
+              }
+              __name(receiveInstantiationResult, "receiveInstantiationResult");
+              if (Module["instantiateWasm"]) {
+                try {
+                  return Module["instantiateWasm"](info2, receiveInstance);
+                } catch (e) {
+                  err(`Module.instantiateWasm callback failed with error: ${e}`);
+                  return false;
+                }
+              }
+              if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();
+              instantiateAsync(wasmBinary, wasmBinaryFile, info2, receiveInstantiationResult);
+              return {};
+            }
+            __name(createWasm, "createWasm");
+            var ASM_CONSTS = {};
+            function ExitStatus(status) {
+              this.name = "ExitStatus";
+              this.message = `Program terminated with exit(${status})`;
+              this.status = status;
+            }
+            __name(ExitStatus, "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_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_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, maxBytesToRead) => {
+              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":
+                  abort("to do getValue(i64) use WASM_BIGINT");
+                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 = 78112;
+            var zeroMemory = /* @__PURE__ */ __name((address, size) => {
+              HEAPU8.fill(0, address, address + size);
+              return address;
+            }, "zeroMemory");
+            var alignMemory = /* @__PURE__ */ __name((size, alignment) => Math.ceil(size / alignment) * alignment, "alignMemory");
+            var getMemory = /* @__PURE__ */ __name((size) => {
+              if (runtimeInitialized) {
+                return zeroMemory(_malloc(size), size);
+              }
+              var ret = ___heap_base;
+              var end = ret + alignMemory(size, 16);
+              ___heap_base = end;
+              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": 28,
+              "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((exports2, replace) => {
+              for (var symName in exports2) {
+                if (isInternalSym(symName)) {
+                  continue;
+                }
+                var value = exports2[symName];
+                if (symName.startsWith("orig$")) {
+                  symName = symName.split("$")[1];
+                  replace = true;
+                }
+                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((exports2, memoryBase2, replace) => {
+              var relocated = {};
+              for (var e in exports2) {
+                var value = exports2[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 dynCallLegacy = /* @__PURE__ */ __name((sig, ptr, args2) => {
+              sig = sig.replace(/p/g, "i");
+              var f = Module["dynCall_" + sig];
+              return f(ptr, ...args2);
+            }, "dynCallLegacy");
+            var dynCall = /* @__PURE__ */ __name((sig, ptr, args2 = []) => {
+              if (sig.includes("j")) {
+                return dynCallLegacy(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);
+              }
+            }, "createInvokeFunction");
+            var resolveGlobalSymbol = /* @__PURE__ */ __name((symName, direct = false) => {
+              var sym;
+              if (direct && "orig$" + symName in wasmImports) {
+                symName = "orig$" + symName;
+              }
+              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((exports2, libName2) => {
+              for (var [sym, exp] of Object.entries(exports2)) {
+                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");
+                }
+                if (sym.startsWith("dynCall_") && !Module.hasOwnProperty(sym)) {
+                  Module[sym] = exp;
+                }
+              }
+            }, "mergeLibSymbols");
+            var asyncLoad = /* @__PURE__ */ __name((url, onload, onerror, noRunDep) => {
+              var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : "";
+              readAsync(url).then((arrayBuffer) => {
+                onload(new Uint8Array(arrayBuffer));
+                if (dep) removeRunDependency(dep);
+              }, (err2) => {
+                if (onerror) {
+                  onerror();
+                } else {
+                  throw `Loading data file "${url}" failed.`;
+                }
+              });
+              if (dep) addRunDependency(dep);
+            }, "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 new Promise(function(resolve, reject) {
+                    asyncLoad(libFile, resolve, reject);
+                  });
+                }
+                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(exports2) {
+                if (dso.global) {
+                  mergeLibSymbols(exports2, libName2);
+                } else if (localScope2) {
+                  Object.assign(localScope2, exports2);
+                }
+                dso.exports = exports2;
+              }
+              __name(moduleLoaded, "moduleLoaded");
+              if (flags2.loadAsync) {
+                return getExports().then((exports2) => {
+                  moduleLoaded(exports2);
+                  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");
+            var noExitRuntime = Module["noExitRuntime"] || true;
+            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":
+                  abort("to do setValue(i64) use WASM_BIGINT");
+                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
+            }, 78112);
+            var ___table_base = new WebAssembly.Global({
+              "value": "i32",
+              "mutable": false
+            }, 1);
+            var __abort_js = /* @__PURE__ */ __name(() => {
+              abort("");
+            }, "__abort_js");
+            __abort_js.sig = "v";
+            var nowIsMonotonic = 1;
+            var __emscripten_get_now_is_monotonic = /* @__PURE__ */ __name(() => nowIsMonotonic, "__emscripten_get_now_is_monotonic");
+            __emscripten_get_now_is_monotonic.sig = "i";
+            var __emscripten_memcpy_js = /* @__PURE__ */ __name((dest, src, num) => HEAPU8.copyWithin(dest, src, src + num), "__emscripten_memcpy_js");
+            __emscripten_memcpy_js.sig = "vppp";
+            var _emscripten_date_now = /* @__PURE__ */ __name(() => Date.now(), "_emscripten_date_now");
+            _emscripten_date_now.sig = "d";
+            var _emscripten_get_now;
+            _emscripten_get_now = /* @__PURE__ */ __name(() => performance.now(), "_emscripten_get_now");
+            _emscripten_get_now.sig = "d";
+            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;
+              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;
+              }
+              var alignUp = /* @__PURE__ */ __name((x, multiple) => x + (multiple - x % multiple) % multiple, "alignUp");
+              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, alignUp(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";
+            var convertI32PairToI53Checked = /* @__PURE__ */ __name((lo, hi) => hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN, "convertI32PairToI53Checked");
+            function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+              var offset = convertI32PairToI53Checked(offset_low, offset_high);
+              return 70;
+            }
+            __name(_fd_seek, "_fd_seek");
+            _fd_seek.sig = "iiiiip";
+            var printCharBuffers = [null, [], []];
+            var printChar = /* @__PURE__ */ __name((stream, curr) => {
+              var buffer = printCharBuffers[stream];
+              if (curr === 0 || curr === 10) {
+                (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+                buffer.length = 0;
+              } else {
+                buffer.push(curr);
+              }
+            }, "printChar");
+            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 (currentLogCallback) {
+                const message = UTF8ToString(messageAddress);
+                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 = 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");
+            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 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 AsciiToString = /* @__PURE__ */ __name((ptr) => {
+              var str = "";
+              while (1) {
+                var ch = HEAPU8[ptr++];
+                if (!ch) return str;
+                str += String.fromCharCode(ch);
+              }
+            }, "AsciiToString");
+            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 */
+              _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
+              /** @export */
+              _emscripten_memcpy_js: __emscripten_memcpy_js,
+              /** @export */
+              emscripten_get_now: _emscripten_get_now,
+              /** @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
+            };
+            var wasmExports = createWasm();
+            var ___wasm_call_ctors = /* @__PURE__ */ __name(() => (___wasm_call_ctors = wasmExports["__wasm_call_ctors"])(), "___wasm_call_ctors");
+            var ___wasm_apply_data_relocs = /* @__PURE__ */ __name(() => (___wasm_apply_data_relocs = wasmExports["__wasm_apply_data_relocs"])(), "___wasm_apply_data_relocs");
+            var _malloc = Module["_malloc"] = (a0) => (_malloc = Module["_malloc"] = wasmExports["malloc"])(a0);
+            var _calloc = Module["_calloc"] = (a0, a1) => (_calloc = Module["_calloc"] = wasmExports["calloc"])(a0, a1);
+            var _realloc = Module["_realloc"] = (a0, a1) => (_realloc = Module["_realloc"] = wasmExports["realloc"])(a0, a1);
+            var _free = Module["_free"] = (a0) => (_free = Module["_free"] = wasmExports["free"])(a0);
+            var _ts_language_symbol_count = Module["_ts_language_symbol_count"] = (a0) => (_ts_language_symbol_count = Module["_ts_language_symbol_count"] = wasmExports["ts_language_symbol_count"])(a0);
+            var _ts_language_state_count = Module["_ts_language_state_count"] = (a0) => (_ts_language_state_count = Module["_ts_language_state_count"] = wasmExports["ts_language_state_count"])(a0);
+            var _ts_language_version = Module["_ts_language_version"] = (a0) => (_ts_language_version = Module["_ts_language_version"] = wasmExports["ts_language_version"])(a0);
+            var _ts_language_field_count = Module["_ts_language_field_count"] = (a0) => (_ts_language_field_count = Module["_ts_language_field_count"] = wasmExports["ts_language_field_count"])(a0);
+            var _ts_language_next_state = Module["_ts_language_next_state"] = (a0, a1, a2) => (_ts_language_next_state = Module["_ts_language_next_state"] = wasmExports["ts_language_next_state"])(a0, a1, a2);
+            var _ts_language_symbol_name = Module["_ts_language_symbol_name"] = (a0, a1) => (_ts_language_symbol_name = Module["_ts_language_symbol_name"] = wasmExports["ts_language_symbol_name"])(a0, a1);
+            var _ts_language_symbol_for_name = Module["_ts_language_symbol_for_name"] = (a0, a1, a2, a3) => (_ts_language_symbol_for_name = Module["_ts_language_symbol_for_name"] = wasmExports["ts_language_symbol_for_name"])(a0, a1, a2, a3);
+            var _strncmp = Module["_strncmp"] = (a0, a1, a2) => (_strncmp = Module["_strncmp"] = wasmExports["strncmp"])(a0, a1, a2);
+            var _ts_language_symbol_type = Module["_ts_language_symbol_type"] = (a0, a1) => (_ts_language_symbol_type = Module["_ts_language_symbol_type"] = wasmExports["ts_language_symbol_type"])(a0, a1);
+            var _ts_language_field_name_for_id = Module["_ts_language_field_name_for_id"] = (a0, a1) => (_ts_language_field_name_for_id = Module["_ts_language_field_name_for_id"] = wasmExports["ts_language_field_name_for_id"])(a0, a1);
+            var _ts_lookahead_iterator_new = Module["_ts_lookahead_iterator_new"] = (a0, a1) => (_ts_lookahead_iterator_new = Module["_ts_lookahead_iterator_new"] = wasmExports["ts_lookahead_iterator_new"])(a0, a1);
+            var _ts_lookahead_iterator_delete = Module["_ts_lookahead_iterator_delete"] = (a0) => (_ts_lookahead_iterator_delete = Module["_ts_lookahead_iterator_delete"] = wasmExports["ts_lookahead_iterator_delete"])(a0);
+            var _ts_lookahead_iterator_reset_state = Module["_ts_lookahead_iterator_reset_state"] = (a0, a1) => (_ts_lookahead_iterator_reset_state = Module["_ts_lookahead_iterator_reset_state"] = wasmExports["ts_lookahead_iterator_reset_state"])(a0, a1);
+            var _ts_lookahead_iterator_reset = Module["_ts_lookahead_iterator_reset"] = (a0, a1, a2) => (_ts_lookahead_iterator_reset = Module["_ts_lookahead_iterator_reset"] = wasmExports["ts_lookahead_iterator_reset"])(a0, a1, a2);
+            var _ts_lookahead_iterator_next = Module["_ts_lookahead_iterator_next"] = (a0) => (_ts_lookahead_iterator_next = Module["_ts_lookahead_iterator_next"] = wasmExports["ts_lookahead_iterator_next"])(a0);
+            var _ts_lookahead_iterator_current_symbol = Module["_ts_lookahead_iterator_current_symbol"] = (a0) => (_ts_lookahead_iterator_current_symbol = Module["_ts_lookahead_iterator_current_symbol"] = wasmExports["ts_lookahead_iterator_current_symbol"])(a0);
+            var _memset = Module["_memset"] = (a0, a1, a2) => (_memset = Module["_memset"] = wasmExports["memset"])(a0, a1, a2);
+            var _memcpy = Module["_memcpy"] = (a0, a1, a2) => (_memcpy = Module["_memcpy"] = wasmExports["memcpy"])(a0, a1, a2);
+            var _ts_parser_delete = Module["_ts_parser_delete"] = (a0) => (_ts_parser_delete = Module["_ts_parser_delete"] = wasmExports["ts_parser_delete"])(a0);
+            var _ts_parser_reset = Module["_ts_parser_reset"] = (a0) => (_ts_parser_reset = Module["_ts_parser_reset"] = wasmExports["ts_parser_reset"])(a0);
+            var _ts_parser_set_language = Module["_ts_parser_set_language"] = (a0, a1) => (_ts_parser_set_language = Module["_ts_parser_set_language"] = wasmExports["ts_parser_set_language"])(a0, a1);
+            var _ts_parser_timeout_micros = Module["_ts_parser_timeout_micros"] = (a0) => (_ts_parser_timeout_micros = Module["_ts_parser_timeout_micros"] = wasmExports["ts_parser_timeout_micros"])(a0);
+            var _ts_parser_set_timeout_micros = Module["_ts_parser_set_timeout_micros"] = (a0, a1, a2) => (_ts_parser_set_timeout_micros = Module["_ts_parser_set_timeout_micros"] = wasmExports["ts_parser_set_timeout_micros"])(a0, a1, a2);
+            var _ts_parser_set_included_ranges = Module["_ts_parser_set_included_ranges"] = (a0, a1, a2) => (_ts_parser_set_included_ranges = Module["_ts_parser_set_included_ranges"] = wasmExports["ts_parser_set_included_ranges"])(a0, a1, a2);
+            var _memmove = Module["_memmove"] = (a0, a1, a2) => (_memmove = Module["_memmove"] = wasmExports["memmove"])(a0, a1, a2);
+            var _memcmp = Module["_memcmp"] = (a0, a1, a2) => (_memcmp = Module["_memcmp"] = wasmExports["memcmp"])(a0, a1, a2);
+            var _ts_query_new = Module["_ts_query_new"] = (a0, a1, a2, a3, a4) => (_ts_query_new = Module["_ts_query_new"] = wasmExports["ts_query_new"])(a0, a1, a2, a3, a4);
+            var _ts_query_delete = Module["_ts_query_delete"] = (a0) => (_ts_query_delete = Module["_ts_query_delete"] = wasmExports["ts_query_delete"])(a0);
+            var _iswspace = Module["_iswspace"] = (a0) => (_iswspace = Module["_iswspace"] = wasmExports["iswspace"])(a0);
+            var _iswalnum = Module["_iswalnum"] = (a0) => (_iswalnum = Module["_iswalnum"] = wasmExports["iswalnum"])(a0);
+            var _ts_query_pattern_count = Module["_ts_query_pattern_count"] = (a0) => (_ts_query_pattern_count = Module["_ts_query_pattern_count"] = wasmExports["ts_query_pattern_count"])(a0);
+            var _ts_query_capture_count = Module["_ts_query_capture_count"] = (a0) => (_ts_query_capture_count = Module["_ts_query_capture_count"] = wasmExports["ts_query_capture_count"])(a0);
+            var _ts_query_string_count = Module["_ts_query_string_count"] = (a0) => (_ts_query_string_count = Module["_ts_query_string_count"] = wasmExports["ts_query_string_count"])(a0);
+            var _ts_query_capture_name_for_id = Module["_ts_query_capture_name_for_id"] = (a0, a1, a2) => (_ts_query_capture_name_for_id = Module["_ts_query_capture_name_for_id"] = wasmExports["ts_query_capture_name_for_id"])(a0, a1, a2);
+            var _ts_query_string_value_for_id = Module["_ts_query_string_value_for_id"] = (a0, a1, a2) => (_ts_query_string_value_for_id = Module["_ts_query_string_value_for_id"] = wasmExports["ts_query_string_value_for_id"])(a0, a1, a2);
+            var _ts_query_predicates_for_pattern = Module["_ts_query_predicates_for_pattern"] = (a0, a1, a2) => (_ts_query_predicates_for_pattern = Module["_ts_query_predicates_for_pattern"] = wasmExports["ts_query_predicates_for_pattern"])(a0, a1, a2);
+            var _ts_query_disable_capture = Module["_ts_query_disable_capture"] = (a0, a1, a2) => (_ts_query_disable_capture = Module["_ts_query_disable_capture"] = wasmExports["ts_query_disable_capture"])(a0, a1, a2);
+            var _ts_tree_copy = Module["_ts_tree_copy"] = (a0) => (_ts_tree_copy = Module["_ts_tree_copy"] = wasmExports["ts_tree_copy"])(a0);
+            var _ts_tree_delete = Module["_ts_tree_delete"] = (a0) => (_ts_tree_delete = Module["_ts_tree_delete"] = wasmExports["ts_tree_delete"])(a0);
+            var _ts_init = Module["_ts_init"] = () => (_ts_init = Module["_ts_init"] = wasmExports["ts_init"])();
+            var _ts_parser_new_wasm = Module["_ts_parser_new_wasm"] = () => (_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"] = (a0, a1) => (_ts_parser_enable_logger_wasm = Module["_ts_parser_enable_logger_wasm"] = wasmExports["ts_parser_enable_logger_wasm"])(a0, a1);
+            var _ts_parser_parse_wasm = Module["_ts_parser_parse_wasm"] = (a0, a1, a2, a3, a4) => (_ts_parser_parse_wasm = Module["_ts_parser_parse_wasm"] = wasmExports["ts_parser_parse_wasm"])(a0, a1, a2, a3, a4);
+            var _ts_parser_included_ranges_wasm = Module["_ts_parser_included_ranges_wasm"] = (a0) => (_ts_parser_included_ranges_wasm = Module["_ts_parser_included_ranges_wasm"] = wasmExports["ts_parser_included_ranges_wasm"])(a0);
+            var _ts_language_type_is_named_wasm = Module["_ts_language_type_is_named_wasm"] = (a0, a1) => (_ts_language_type_is_named_wasm = Module["_ts_language_type_is_named_wasm"] = wasmExports["ts_language_type_is_named_wasm"])(a0, a1);
+            var _ts_language_type_is_visible_wasm = Module["_ts_language_type_is_visible_wasm"] = (a0, a1) => (_ts_language_type_is_visible_wasm = Module["_ts_language_type_is_visible_wasm"] = wasmExports["ts_language_type_is_visible_wasm"])(a0, a1);
+            var _ts_tree_root_node_wasm = Module["_ts_tree_root_node_wasm"] = (a0) => (_ts_tree_root_node_wasm = Module["_ts_tree_root_node_wasm"] = wasmExports["ts_tree_root_node_wasm"])(a0);
+            var _ts_tree_root_node_with_offset_wasm = Module["_ts_tree_root_node_with_offset_wasm"] = (a0) => (_ts_tree_root_node_with_offset_wasm = Module["_ts_tree_root_node_with_offset_wasm"] = wasmExports["ts_tree_root_node_with_offset_wasm"])(a0);
+            var _ts_tree_edit_wasm = Module["_ts_tree_edit_wasm"] = (a0) => (_ts_tree_edit_wasm = Module["_ts_tree_edit_wasm"] = wasmExports["ts_tree_edit_wasm"])(a0);
+            var _ts_tree_included_ranges_wasm = Module["_ts_tree_included_ranges_wasm"] = (a0) => (_ts_tree_included_ranges_wasm = Module["_ts_tree_included_ranges_wasm"] = wasmExports["ts_tree_included_ranges_wasm"])(a0);
+            var _ts_tree_get_changed_ranges_wasm = Module["_ts_tree_get_changed_ranges_wasm"] = (a0, a1) => (_ts_tree_get_changed_ranges_wasm = Module["_ts_tree_get_changed_ranges_wasm"] = wasmExports["ts_tree_get_changed_ranges_wasm"])(a0, a1);
+            var _ts_tree_cursor_new_wasm = Module["_ts_tree_cursor_new_wasm"] = (a0) => (_ts_tree_cursor_new_wasm = Module["_ts_tree_cursor_new_wasm"] = wasmExports["ts_tree_cursor_new_wasm"])(a0);
+            var _ts_tree_cursor_delete_wasm = Module["_ts_tree_cursor_delete_wasm"] = (a0) => (_ts_tree_cursor_delete_wasm = Module["_ts_tree_cursor_delete_wasm"] = wasmExports["ts_tree_cursor_delete_wasm"])(a0);
+            var _ts_tree_cursor_reset_wasm = Module["_ts_tree_cursor_reset_wasm"] = (a0) => (_ts_tree_cursor_reset_wasm = Module["_ts_tree_cursor_reset_wasm"] = wasmExports["ts_tree_cursor_reset_wasm"])(a0);
+            var _ts_tree_cursor_reset_to_wasm = Module["_ts_tree_cursor_reset_to_wasm"] = (a0, a1) => (_ts_tree_cursor_reset_to_wasm = Module["_ts_tree_cursor_reset_to_wasm"] = wasmExports["ts_tree_cursor_reset_to_wasm"])(a0, a1);
+            var _ts_tree_cursor_goto_first_child_wasm = Module["_ts_tree_cursor_goto_first_child_wasm"] = (a0) => (_ts_tree_cursor_goto_first_child_wasm = Module["_ts_tree_cursor_goto_first_child_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_wasm"])(a0);
+            var _ts_tree_cursor_goto_last_child_wasm = Module["_ts_tree_cursor_goto_last_child_wasm"] = (a0) => (_ts_tree_cursor_goto_last_child_wasm = Module["_ts_tree_cursor_goto_last_child_wasm"] = wasmExports["ts_tree_cursor_goto_last_child_wasm"])(a0);
+            var _ts_tree_cursor_goto_first_child_for_index_wasm = Module["_ts_tree_cursor_goto_first_child_for_index_wasm"] = (a0) => (_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"])(a0);
+            var _ts_tree_cursor_goto_first_child_for_position_wasm = Module["_ts_tree_cursor_goto_first_child_for_position_wasm"] = (a0) => (_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"])(a0);
+            var _ts_tree_cursor_goto_next_sibling_wasm = Module["_ts_tree_cursor_goto_next_sibling_wasm"] = (a0) => (_ts_tree_cursor_goto_next_sibling_wasm = Module["_ts_tree_cursor_goto_next_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_next_sibling_wasm"])(a0);
+            var _ts_tree_cursor_goto_previous_sibling_wasm = Module["_ts_tree_cursor_goto_previous_sibling_wasm"] = (a0) => (_ts_tree_cursor_goto_previous_sibling_wasm = Module["_ts_tree_cursor_goto_previous_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_previous_sibling_wasm"])(a0);
+            var _ts_tree_cursor_goto_descendant_wasm = Module["_ts_tree_cursor_goto_descendant_wasm"] = (a0, a1) => (_ts_tree_cursor_goto_descendant_wasm = Module["_ts_tree_cursor_goto_descendant_wasm"] = wasmExports["ts_tree_cursor_goto_descendant_wasm"])(a0, a1);
+            var _ts_tree_cursor_goto_parent_wasm = Module["_ts_tree_cursor_goto_parent_wasm"] = (a0) => (_ts_tree_cursor_goto_parent_wasm = Module["_ts_tree_cursor_goto_parent_wasm"] = wasmExports["ts_tree_cursor_goto_parent_wasm"])(a0);
+            var _ts_tree_cursor_current_node_type_id_wasm = Module["_ts_tree_cursor_current_node_type_id_wasm"] = (a0) => (_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"])(a0);
+            var _ts_tree_cursor_current_node_state_id_wasm = Module["_ts_tree_cursor_current_node_state_id_wasm"] = (a0) => (_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"])(a0);
+            var _ts_tree_cursor_current_node_is_named_wasm = Module["_ts_tree_cursor_current_node_is_named_wasm"] = (a0) => (_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"])(a0);
+            var _ts_tree_cursor_current_node_is_missing_wasm = Module["_ts_tree_cursor_current_node_is_missing_wasm"] = (a0) => (_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"])(a0);
+            var _ts_tree_cursor_current_node_id_wasm = Module["_ts_tree_cursor_current_node_id_wasm"] = (a0) => (_ts_tree_cursor_current_node_id_wasm = Module["_ts_tree_cursor_current_node_id_wasm"] = wasmExports["ts_tree_cursor_current_node_id_wasm"])(a0);
+            var _ts_tree_cursor_start_position_wasm = Module["_ts_tree_cursor_start_position_wasm"] = (a0) => (_ts_tree_cursor_start_position_wasm = Module["_ts_tree_cursor_start_position_wasm"] = wasmExports["ts_tree_cursor_start_position_wasm"])(a0);
+            var _ts_tree_cursor_end_position_wasm = Module["_ts_tree_cursor_end_position_wasm"] = (a0) => (_ts_tree_cursor_end_position_wasm = Module["_ts_tree_cursor_end_position_wasm"] = wasmExports["ts_tree_cursor_end_position_wasm"])(a0);
+            var _ts_tree_cursor_start_index_wasm = Module["_ts_tree_cursor_start_index_wasm"] = (a0) => (_ts_tree_cursor_start_index_wasm = Module["_ts_tree_cursor_start_index_wasm"] = wasmExports["ts_tree_cursor_start_index_wasm"])(a0);
+            var _ts_tree_cursor_end_index_wasm = Module["_ts_tree_cursor_end_index_wasm"] = (a0) => (_ts_tree_cursor_end_index_wasm = Module["_ts_tree_cursor_end_index_wasm"] = wasmExports["ts_tree_cursor_end_index_wasm"])(a0);
+            var _ts_tree_cursor_current_field_id_wasm = Module["_ts_tree_cursor_current_field_id_wasm"] = (a0) => (_ts_tree_cursor_current_field_id_wasm = Module["_ts_tree_cursor_current_field_id_wasm"] = wasmExports["ts_tree_cursor_current_field_id_wasm"])(a0);
+            var _ts_tree_cursor_current_depth_wasm = Module["_ts_tree_cursor_current_depth_wasm"] = (a0) => (_ts_tree_cursor_current_depth_wasm = Module["_ts_tree_cursor_current_depth_wasm"] = wasmExports["ts_tree_cursor_current_depth_wasm"])(a0);
+            var _ts_tree_cursor_current_descendant_index_wasm = Module["_ts_tree_cursor_current_descendant_index_wasm"] = (a0) => (_ts_tree_cursor_current_descendant_index_wasm = Module["_ts_tree_cursor_current_descendant_index_wasm"] = wasmExports["ts_tree_cursor_current_descendant_index_wasm"])(a0);
+            var _ts_tree_cursor_current_node_wasm = Module["_ts_tree_cursor_current_node_wasm"] = (a0) => (_ts_tree_cursor_current_node_wasm = Module["_ts_tree_cursor_current_node_wasm"] = wasmExports["ts_tree_cursor_current_node_wasm"])(a0);
+            var _ts_node_symbol_wasm = Module["_ts_node_symbol_wasm"] = (a0) => (_ts_node_symbol_wasm = Module["_ts_node_symbol_wasm"] = wasmExports["ts_node_symbol_wasm"])(a0);
+            var _ts_node_field_name_for_child_wasm = Module["_ts_node_field_name_for_child_wasm"] = (a0, a1) => (_ts_node_field_name_for_child_wasm = Module["_ts_node_field_name_for_child_wasm"] = wasmExports["ts_node_field_name_for_child_wasm"])(a0, a1);
+            var _ts_node_children_by_field_id_wasm = Module["_ts_node_children_by_field_id_wasm"] = (a0, a1) => (_ts_node_children_by_field_id_wasm = Module["_ts_node_children_by_field_id_wasm"] = wasmExports["ts_node_children_by_field_id_wasm"])(a0, a1);
+            var _ts_node_first_child_for_byte_wasm = Module["_ts_node_first_child_for_byte_wasm"] = (a0) => (_ts_node_first_child_for_byte_wasm = Module["_ts_node_first_child_for_byte_wasm"] = wasmExports["ts_node_first_child_for_byte_wasm"])(a0);
+            var _ts_node_first_named_child_for_byte_wasm = Module["_ts_node_first_named_child_for_byte_wasm"] = (a0) => (_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"])(a0);
+            var _ts_node_grammar_symbol_wasm = Module["_ts_node_grammar_symbol_wasm"] = (a0) => (_ts_node_grammar_symbol_wasm = Module["_ts_node_grammar_symbol_wasm"] = wasmExports["ts_node_grammar_symbol_wasm"])(a0);
+            var _ts_node_child_count_wasm = Module["_ts_node_child_count_wasm"] = (a0) => (_ts_node_child_count_wasm = Module["_ts_node_child_count_wasm"] = wasmExports["ts_node_child_count_wasm"])(a0);
+            var _ts_node_named_child_count_wasm = Module["_ts_node_named_child_count_wasm"] = (a0) => (_ts_node_named_child_count_wasm = Module["_ts_node_named_child_count_wasm"] = wasmExports["ts_node_named_child_count_wasm"])(a0);
+            var _ts_node_child_wasm = Module["_ts_node_child_wasm"] = (a0, a1) => (_ts_node_child_wasm = Module["_ts_node_child_wasm"] = wasmExports["ts_node_child_wasm"])(a0, a1);
+            var _ts_node_named_child_wasm = Module["_ts_node_named_child_wasm"] = (a0, a1) => (_ts_node_named_child_wasm = Module["_ts_node_named_child_wasm"] = wasmExports["ts_node_named_child_wasm"])(a0, a1);
+            var _ts_node_child_by_field_id_wasm = Module["_ts_node_child_by_field_id_wasm"] = (a0, a1) => (_ts_node_child_by_field_id_wasm = Module["_ts_node_child_by_field_id_wasm"] = wasmExports["ts_node_child_by_field_id_wasm"])(a0, a1);
+            var _ts_node_next_sibling_wasm = Module["_ts_node_next_sibling_wasm"] = (a0) => (_ts_node_next_sibling_wasm = Module["_ts_node_next_sibling_wasm"] = wasmExports["ts_node_next_sibling_wasm"])(a0);
+            var _ts_node_prev_sibling_wasm = Module["_ts_node_prev_sibling_wasm"] = (a0) => (_ts_node_prev_sibling_wasm = Module["_ts_node_prev_sibling_wasm"] = wasmExports["ts_node_prev_sibling_wasm"])(a0);
+            var _ts_node_next_named_sibling_wasm = Module["_ts_node_next_named_sibling_wasm"] = (a0) => (_ts_node_next_named_sibling_wasm = Module["_ts_node_next_named_sibling_wasm"] = wasmExports["ts_node_next_named_sibling_wasm"])(a0);
+            var _ts_node_prev_named_sibling_wasm = Module["_ts_node_prev_named_sibling_wasm"] = (a0) => (_ts_node_prev_named_sibling_wasm = Module["_ts_node_prev_named_sibling_wasm"] = wasmExports["ts_node_prev_named_sibling_wasm"])(a0);
+            var _ts_node_descendant_count_wasm = Module["_ts_node_descendant_count_wasm"] = (a0) => (_ts_node_descendant_count_wasm = Module["_ts_node_descendant_count_wasm"] = wasmExports["ts_node_descendant_count_wasm"])(a0);
+            var _ts_node_parent_wasm = Module["_ts_node_parent_wasm"] = (a0) => (_ts_node_parent_wasm = Module["_ts_node_parent_wasm"] = wasmExports["ts_node_parent_wasm"])(a0);
+            var _ts_node_descendant_for_index_wasm = Module["_ts_node_descendant_for_index_wasm"] = (a0) => (_ts_node_descendant_for_index_wasm = Module["_ts_node_descendant_for_index_wasm"] = wasmExports["ts_node_descendant_for_index_wasm"])(a0);
+            var _ts_node_named_descendant_for_index_wasm = Module["_ts_node_named_descendant_for_index_wasm"] = (a0) => (_ts_node_named_descendant_for_index_wasm = Module["_ts_node_named_descendant_for_index_wasm"] = wasmExports["ts_node_named_descendant_for_index_wasm"])(a0);
+            var _ts_node_descendant_for_position_wasm = Module["_ts_node_descendant_for_position_wasm"] = (a0) => (_ts_node_descendant_for_position_wasm = Module["_ts_node_descendant_for_position_wasm"] = wasmExports["ts_node_descendant_for_position_wasm"])(a0);
+            var _ts_node_named_descendant_for_position_wasm = Module["_ts_node_named_descendant_for_position_wasm"] = (a0) => (_ts_node_named_descendant_for_position_wasm = Module["_ts_node_named_descendant_for_position_wasm"] = wasmExports["ts_node_named_descendant_for_position_wasm"])(a0);
+            var _ts_node_start_point_wasm = Module["_ts_node_start_point_wasm"] = (a0) => (_ts_node_start_point_wasm = Module["_ts_node_start_point_wasm"] = wasmExports["ts_node_start_point_wasm"])(a0);
+            var _ts_node_end_point_wasm = Module["_ts_node_end_point_wasm"] = (a0) => (_ts_node_end_point_wasm = Module["_ts_node_end_point_wasm"] = wasmExports["ts_node_end_point_wasm"])(a0);
+            var _ts_node_start_index_wasm = Module["_ts_node_start_index_wasm"] = (a0) => (_ts_node_start_index_wasm = Module["_ts_node_start_index_wasm"] = wasmExports["ts_node_start_index_wasm"])(a0);
+            var _ts_node_end_index_wasm = Module["_ts_node_end_index_wasm"] = (a0) => (_ts_node_end_index_wasm = Module["_ts_node_end_index_wasm"] = wasmExports["ts_node_end_index_wasm"])(a0);
+            var _ts_node_to_string_wasm = Module["_ts_node_to_string_wasm"] = (a0) => (_ts_node_to_string_wasm = Module["_ts_node_to_string_wasm"] = wasmExports["ts_node_to_string_wasm"])(a0);
+            var _ts_node_children_wasm = Module["_ts_node_children_wasm"] = (a0) => (_ts_node_children_wasm = Module["_ts_node_children_wasm"] = wasmExports["ts_node_children_wasm"])(a0);
+            var _ts_node_named_children_wasm = Module["_ts_node_named_children_wasm"] = (a0) => (_ts_node_named_children_wasm = Module["_ts_node_named_children_wasm"] = wasmExports["ts_node_named_children_wasm"])(a0);
+            var _ts_node_descendants_of_type_wasm = Module["_ts_node_descendants_of_type_wasm"] = (a0, a1, a2, a3, a4, a5, a6) => (_ts_node_descendants_of_type_wasm = Module["_ts_node_descendants_of_type_wasm"] = wasmExports["ts_node_descendants_of_type_wasm"])(a0, a1, a2, a3, a4, a5, a6);
+            var _ts_node_is_named_wasm = Module["_ts_node_is_named_wasm"] = (a0) => (_ts_node_is_named_wasm = Module["_ts_node_is_named_wasm"] = wasmExports["ts_node_is_named_wasm"])(a0);
+            var _ts_node_has_changes_wasm = Module["_ts_node_has_changes_wasm"] = (a0) => (_ts_node_has_changes_wasm = Module["_ts_node_has_changes_wasm"] = wasmExports["ts_node_has_changes_wasm"])(a0);
+            var _ts_node_has_error_wasm = Module["_ts_node_has_error_wasm"] = (a0) => (_ts_node_has_error_wasm = Module["_ts_node_has_error_wasm"] = wasmExports["ts_node_has_error_wasm"])(a0);
+            var _ts_node_is_error_wasm = Module["_ts_node_is_error_wasm"] = (a0) => (_ts_node_is_error_wasm = Module["_ts_node_is_error_wasm"] = wasmExports["ts_node_is_error_wasm"])(a0);
+            var _ts_node_is_missing_wasm = Module["_ts_node_is_missing_wasm"] = (a0) => (_ts_node_is_missing_wasm = Module["_ts_node_is_missing_wasm"] = wasmExports["ts_node_is_missing_wasm"])(a0);
+            var _ts_node_is_extra_wasm = Module["_ts_node_is_extra_wasm"] = (a0) => (_ts_node_is_extra_wasm = Module["_ts_node_is_extra_wasm"] = wasmExports["ts_node_is_extra_wasm"])(a0);
+            var _ts_node_parse_state_wasm = Module["_ts_node_parse_state_wasm"] = (a0) => (_ts_node_parse_state_wasm = Module["_ts_node_parse_state_wasm"] = wasmExports["ts_node_parse_state_wasm"])(a0);
+            var _ts_node_next_parse_state_wasm = Module["_ts_node_next_parse_state_wasm"] = (a0) => (_ts_node_next_parse_state_wasm = Module["_ts_node_next_parse_state_wasm"] = wasmExports["ts_node_next_parse_state_wasm"])(a0);
+            var _ts_query_matches_wasm = Module["_ts_query_matches_wasm"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (_ts_query_matches_wasm = Module["_ts_query_matches_wasm"] = wasmExports["ts_query_matches_wasm"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+            var _ts_query_captures_wasm = Module["_ts_query_captures_wasm"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (_ts_query_captures_wasm = Module["_ts_query_captures_wasm"] = wasmExports["ts_query_captures_wasm"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+            var _iswalpha = Module["_iswalpha"] = (a0) => (_iswalpha = Module["_iswalpha"] = wasmExports["iswalpha"])(a0);
+            var _iswblank = Module["_iswblank"] = (a0) => (_iswblank = Module["_iswblank"] = wasmExports["iswblank"])(a0);
+            var _iswdigit = Module["_iswdigit"] = (a0) => (_iswdigit = Module["_iswdigit"] = wasmExports["iswdigit"])(a0);
+            var _iswlower = Module["_iswlower"] = (a0) => (_iswlower = Module["_iswlower"] = wasmExports["iswlower"])(a0);
+            var _iswupper = Module["_iswupper"] = (a0) => (_iswupper = Module["_iswupper"] = wasmExports["iswupper"])(a0);
+            var _iswxdigit = Module["_iswxdigit"] = (a0) => (_iswxdigit = Module["_iswxdigit"] = wasmExports["iswxdigit"])(a0);
+            var _memchr = Module["_memchr"] = (a0, a1, a2) => (_memchr = Module["_memchr"] = wasmExports["memchr"])(a0, a1, a2);
+            var _strlen = Module["_strlen"] = (a0) => (_strlen = Module["_strlen"] = wasmExports["strlen"])(a0);
+            var _strcmp = Module["_strcmp"] = (a0, a1) => (_strcmp = Module["_strcmp"] = wasmExports["strcmp"])(a0, a1);
+            var _strncat = Module["_strncat"] = (a0, a1, a2) => (_strncat = Module["_strncat"] = wasmExports["strncat"])(a0, a1, a2);
+            var _strncpy = Module["_strncpy"] = (a0, a1, a2) => (_strncpy = Module["_strncpy"] = wasmExports["strncpy"])(a0, a1, a2);
+            var _towlower = Module["_towlower"] = (a0) => (_towlower = Module["_towlower"] = wasmExports["towlower"])(a0);
+            var _towupper = Module["_towupper"] = (a0) => (_towupper = Module["_towupper"] = wasmExports["towupper"])(a0);
+            var _setThrew = /* @__PURE__ */ __name((a0, a1) => (_setThrew = wasmExports["setThrew"])(a0, a1), "_setThrew");
+            var __emscripten_stack_restore = /* @__PURE__ */ __name((a0) => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0), "__emscripten_stack_restore");
+            var __emscripten_stack_alloc = /* @__PURE__ */ __name((a0) => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0), "__emscripten_stack_alloc");
+            var _emscripten_stack_get_current = /* @__PURE__ */ __name(() => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])(), "_emscripten_stack_get_current");
+            var dynCall_jiji = Module["dynCall_jiji"] = (a0, a1, a2, a3, a4) => (dynCall_jiji = Module["dynCall_jiji"] = wasmExports["dynCall_jiji"])(a0, a1, a2, a3, a4);
+            var _orig$ts_parser_timeout_micros = Module["_orig$ts_parser_timeout_micros"] = (a0) => (_orig$ts_parser_timeout_micros = Module["_orig$ts_parser_timeout_micros"] = wasmExports["orig$ts_parser_timeout_micros"])(a0);
+            var _orig$ts_parser_set_timeout_micros = Module["_orig$ts_parser_set_timeout_micros"] = (a0, a1) => (_orig$ts_parser_set_timeout_micros = Module["_orig$ts_parser_set_timeout_micros"] = wasmExports["orig$ts_parser_set_timeout_micros"])(a0, a1);
+            Module["AsciiToString"] = AsciiToString;
+            Module["stringToUTF16"] = stringToUTF16;
+            var calledRun;
+            dependenciesFulfilled = /* @__PURE__ */ __name(function runCaller() {
+              if (!calledRun) run();
+              if (!calledRun) dependenciesFulfilled = runCaller;
+            }, "runCaller");
+            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) {
+                return;
+              }
+              preRun();
+              if (runDependencies > 0) {
+                return;
+              }
+              function doRun() {
+                if (calledRun) return;
+                calledRun = true;
+                Module["calledRun"] = true;
+                if (ABORT) return;
+                initRuntime();
+                preMain();
+                Module["onRuntimeInitialized"]?.();
+                if (shouldRunNow) callMain(args2);
+                postRun();
+              }
+              __name(doRun, "doRun");
+              if (Module["setStatus"]) {
+                Module["setStatus"]("Running...");
+                setTimeout(function() {
+                  setTimeout(function() {
+                    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()();
+              }
+            }
+            var shouldRunNow = true;
+            if (Module["noInitialRun"]) shouldRunNow = false;
+            run();
+            const C = Module;
+            const INTERNAL = {};
+            const SIZE_OF_INT = 4;
+            const SIZE_OF_CURSOR = 4 * SIZE_OF_INT;
+            const SIZE_OF_NODE = 5 * SIZE_OF_INT;
+            const SIZE_OF_POINT = 2 * SIZE_OF_INT;
+            const SIZE_OF_RANGE = 2 * SIZE_OF_INT + 2 * SIZE_OF_POINT;
+            const ZERO_POINT = {
+              row: 0,
+              column: 0
+            };
+            const QUERY_WORD_REGEX = /[\w-.]*/g;
+            const PREDICATE_STEP_TYPE_CAPTURE = 1;
+            const PREDICATE_STEP_TYPE_STRING = 2;
+            const LANGUAGE_FUNCTION_REGEX = /^_?tree_sitter_\w+/;
+            let VERSION;
+            let MIN_COMPATIBLE_VERSION;
+            let TRANSFER_BUFFER;
+            let currentParseCallback;
+            let currentLogCallback;
+            class ParserImpl {
+              static {
+                __name(this, "ParserImpl");
+              }
+              static init() {
+                TRANSFER_BUFFER = C._ts_init();
+                VERSION = getValue(TRANSFER_BUFFER, "i32");
+                MIN_COMPATIBLE_VERSION = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+              }
+              initialize() {
+                C._ts_parser_new_wasm();
+                this[0] = getValue(TRANSFER_BUFFER, "i32");
+                this[1] = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+              }
+              delete() {
+                C._ts_parser_delete(this[0]);
+                C._free(this[1]);
+                this[0] = 0;
+                this[1] = 0;
+              }
+              setLanguage(language) {
+                let address;
+                if (!language) {
+                  address = 0;
+                  language = null;
+                } else if (language.constructor === Language) {
+                  address = language[0];
+                  const version = C._ts_language_version(address);
+                  if (version < MIN_COMPATIBLE_VERSION || VERSION < version) {
+                    throw new Error(`Incompatible language version ${version}. Compatibility range ${MIN_COMPATIBLE_VERSION} through ${VERSION}.`);
+                  }
+                } else {
+                  throw new Error("Argument must be a Language");
+                }
+                this.language = language;
+                C._ts_parser_set_language(this[0], address);
+                return this;
+              }
+              getLanguage() {
+                return this.language;
+              }
+              parse(callback, oldTree, options) {
+                if (typeof callback === "string") {
+                  currentParseCallback = /* @__PURE__ */ __name((index, _) => callback.slice(index), "currentParseCallback");
+                } else if (typeof callback === "function") {
+                  currentParseCallback = callback;
+                } else {
+                  throw new Error("Argument must be a string or a function");
+                }
+                if (this.logCallback) {
+                  currentLogCallback = this.logCallback;
+                  C._ts_parser_enable_logger_wasm(this[0], 1);
+                } else {
+                  currentLogCallback = null;
+                  C._ts_parser_enable_logger_wasm(this[0], 0);
+                }
+                let rangeCount = 0;
+                let rangeAddress = 0;
+                if (options?.includedRanges) {
+                  rangeCount = options.includedRanges.length;
+                  rangeAddress = C._calloc(rangeCount, SIZE_OF_RANGE);
+                  let address = rangeAddress;
+                  for (let i2 = 0; i2 < rangeCount; i2++) {
+                    marshalRange(address, options.includedRanges[i2]);
+                    address += SIZE_OF_RANGE;
+                  }
+                }
+                const treeAddress = C._ts_parser_parse_wasm(this[0], this[1], oldTree ? oldTree[0] : 0, rangeAddress, rangeCount);
+                if (!treeAddress) {
+                  currentParseCallback = null;
+                  currentLogCallback = null;
+                  throw new Error("Parsing failed");
+                }
+                const result = new Tree(INTERNAL, treeAddress, this.language, currentParseCallback);
+                currentParseCallback = null;
+                currentLogCallback = null;
+                return result;
+              }
+              reset() {
+                C._ts_parser_reset(this[0]);
+              }
+              getIncludedRanges() {
+                C._ts_parser_included_ranges_wasm(this[0]);
+                const count = getValue(TRANSFER_BUFFER, "i32");
+                const buffer = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                const result = new Array(count);
+                if (count > 0) {
+                  let address = buffer;
+                  for (let i2 = 0; i2 < count; i2++) {
+                    result[i2] = unmarshalRange(address);
+                    address += SIZE_OF_RANGE;
+                  }
+                  C._free(buffer);
+                }
+                return result;
+              }
+              getTimeoutMicros() {
+                return C._ts_parser_timeout_micros(this[0]);
+              }
+              setTimeoutMicros(timeout) {
+                C._ts_parser_set_timeout_micros(this[0], timeout);
+              }
+              setLogger(callback) {
+                if (!callback) {
+                  callback = null;
+                } else if (typeof callback !== "function") {
+                  throw new Error("Logger callback must be a function");
+                }
+                this.logCallback = callback;
+                return this;
+              }
+              getLogger() {
+                return this.logCallback;
+              }
+            }
+            class Tree {
+              static {
+                __name(this, "Tree");
+              }
+              constructor(internal, address, language, textCallback) {
+                assertInternal(internal);
+                this[0] = address;
+                this.language = language;
+                this.textCallback = textCallback;
+              }
+              copy() {
+                const address = C._ts_tree_copy(this[0]);
+                return new Tree(INTERNAL, address, this.language, this.textCallback);
+              }
+              delete() {
+                C._ts_tree_delete(this[0]);
+                this[0] = 0;
+              }
+              edit(edit) {
+                marshalEdit(edit);
+                C._ts_tree_edit_wasm(this[0]);
+              }
+              get rootNode() {
+                C._ts_tree_root_node_wasm(this[0]);
+                return unmarshalNode(this);
+              }
+              rootNodeWithOffset(offsetBytes, offsetExtent) {
+                const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+                setValue(address, offsetBytes, "i32");
+                marshalPoint(address + SIZE_OF_INT, offsetExtent);
+                C._ts_tree_root_node_with_offset_wasm(this[0]);
+                return unmarshalNode(this);
+              }
+              getLanguage() {
+                return this.language;
+              }
+              walk() {
+                return this.rootNode.walk();
+              }
+              getChangedRanges(other) {
+                if (other.constructor !== Tree) {
+                  throw new TypeError("Argument must be a Tree");
+                }
+                C._ts_tree_get_changed_ranges_wasm(this[0], other[0]);
+                const count = getValue(TRANSFER_BUFFER, "i32");
+                const buffer = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                const result = new Array(count);
+                if (count > 0) {
+                  let address = buffer;
+                  for (let i2 = 0; i2 < count; i2++) {
+                    result[i2] = unmarshalRange(address);
+                    address += SIZE_OF_RANGE;
+                  }
+                  C._free(buffer);
+                }
+                return result;
+              }
+              getIncludedRanges() {
+                C._ts_tree_included_ranges_wasm(this[0]);
+                const count = getValue(TRANSFER_BUFFER, "i32");
+                const buffer = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                const result = new Array(count);
+                if (count > 0) {
+                  let address = buffer;
+                  for (let i2 = 0; i2 < count; i2++) {
+                    result[i2] = unmarshalRange(address);
+                    address += SIZE_OF_RANGE;
+                  }
+                  C._free(buffer);
+                }
+                return result;
+              }
+            }
+            class Node {
+              static {
+                __name(this, "Node");
+              }
+              constructor(internal, tree) {
+                assertInternal(internal);
+                this.tree = tree;
+              }
+              get typeId() {
+                marshalNode(this);
+                return C._ts_node_symbol_wasm(this.tree[0]);
+              }
+              get grammarId() {
+                marshalNode(this);
+                return C._ts_node_grammar_symbol_wasm(this.tree[0]);
+              }
+              get type() {
+                return this.tree.language.types[this.typeId] || "ERROR";
+              }
+              get grammarType() {
+                return this.tree.language.types[this.grammarId] || "ERROR";
+              }
+              get endPosition() {
+                marshalNode(this);
+                C._ts_node_end_point_wasm(this.tree[0]);
+                return unmarshalPoint(TRANSFER_BUFFER);
+              }
+              get endIndex() {
+                marshalNode(this);
+                return C._ts_node_end_index_wasm(this.tree[0]);
+              }
+              get text() {
+                return getText(this.tree, this.startIndex, this.endIndex);
+              }
+              get parseState() {
+                marshalNode(this);
+                return C._ts_node_parse_state_wasm(this.tree[0]);
+              }
+              get nextParseState() {
+                marshalNode(this);
+                return C._ts_node_next_parse_state_wasm(this.tree[0]);
+              }
+              get isNamed() {
+                marshalNode(this);
+                return C._ts_node_is_named_wasm(this.tree[0]) === 1;
+              }
+              get hasError() {
+                marshalNode(this);
+                return C._ts_node_has_error_wasm(this.tree[0]) === 1;
+              }
+              get hasChanges() {
+                marshalNode(this);
+                return C._ts_node_has_changes_wasm(this.tree[0]) === 1;
+              }
+              get isError() {
+                marshalNode(this);
+                return C._ts_node_is_error_wasm(this.tree[0]) === 1;
+              }
+              get isMissing() {
+                marshalNode(this);
+                return C._ts_node_is_missing_wasm(this.tree[0]) === 1;
+              }
+              get isExtra() {
+                marshalNode(this);
+                return C._ts_node_is_extra_wasm(this.tree[0]) === 1;
+              }
+              equals(other) {
+                return this.id === other.id;
+              }
+              child(index) {
+                marshalNode(this);
+                C._ts_node_child_wasm(this.tree[0], index);
+                return unmarshalNode(this.tree);
+              }
+              namedChild(index) {
+                marshalNode(this);
+                C._ts_node_named_child_wasm(this.tree[0], index);
+                return unmarshalNode(this.tree);
+              }
+              childForFieldId(fieldId) {
+                marshalNode(this);
+                C._ts_node_child_by_field_id_wasm(this.tree[0], fieldId);
+                return unmarshalNode(this.tree);
+              }
+              childForFieldName(fieldName) {
+                const fieldId = this.tree.language.fields.indexOf(fieldName);
+                if (fieldId !== -1) return this.childForFieldId(fieldId);
+                return null;
+              }
+              fieldNameForChild(index) {
+                marshalNode(this);
+                const address = C._ts_node_field_name_for_child_wasm(this.tree[0], index);
+                if (!address) {
+                  return null;
+                }
+                const result = AsciiToString(address);
+                return result;
+              }
+              childrenForFieldName(fieldName) {
+                const fieldId = this.tree.language.fields.indexOf(fieldName);
+                if (fieldId !== -1 && fieldId !== 0) return this.childrenForFieldId(fieldId);
+                return [];
+              }
+              childrenForFieldId(fieldId) {
+                marshalNode(this);
+                C._ts_node_children_by_field_id_wasm(this.tree[0], fieldId);
+                const count = getValue(TRANSFER_BUFFER, "i32");
+                const buffer = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                const result = new Array(count);
+                if (count > 0) {
+                  let address = buffer;
+                  for (let i2 = 0; i2 < count; i2++) {
+                    result[i2] = unmarshalNode(this.tree, address);
+                    address += SIZE_OF_NODE;
+                  }
+                  C._free(buffer);
+                }
+                return result;
+              }
+              firstChildForIndex(index) {
+                marshalNode(this);
+                const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+                setValue(address, index, "i32");
+                C._ts_node_first_child_for_byte_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              firstNamedChildForIndex(index) {
+                marshalNode(this);
+                const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+                setValue(address, index, "i32");
+                C._ts_node_first_named_child_for_byte_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              get childCount() {
+                marshalNode(this);
+                return C._ts_node_child_count_wasm(this.tree[0]);
+              }
+              get namedChildCount() {
+                marshalNode(this);
+                return C._ts_node_named_child_count_wasm(this.tree[0]);
+              }
+              get firstChild() {
+                return this.child(0);
+              }
+              get firstNamedChild() {
+                return this.namedChild(0);
+              }
+              get lastChild() {
+                return this.child(this.childCount - 1);
+              }
+              get lastNamedChild() {
+                return this.namedChild(this.namedChildCount - 1);
+              }
+              get children() {
+                if (!this._children) {
+                  marshalNode(this);
+                  C._ts_node_children_wasm(this.tree[0]);
+                  const count = getValue(TRANSFER_BUFFER, "i32");
+                  const buffer = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                  this._children = new Array(count);
+                  if (count > 0) {
+                    let address = buffer;
+                    for (let i2 = 0; i2 < count; i2++) {
+                      this._children[i2] = unmarshalNode(this.tree, address);
+                      address += SIZE_OF_NODE;
+                    }
+                    C._free(buffer);
+                  }
+                }
+                return this._children;
+              }
+              get namedChildren() {
+                if (!this._namedChildren) {
+                  marshalNode(this);
+                  C._ts_node_named_children_wasm(this.tree[0]);
+                  const count = getValue(TRANSFER_BUFFER, "i32");
+                  const buffer = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                  this._namedChildren = new Array(count);
+                  if (count > 0) {
+                    let address = buffer;
+                    for (let i2 = 0; i2 < count; i2++) {
+                      this._namedChildren[i2] = unmarshalNode(this.tree, address);
+                      address += SIZE_OF_NODE;
+                    }
+                    C._free(buffer);
+                  }
+                }
+                return this._namedChildren;
+              }
+              descendantsOfType(types, startPosition, endPosition) {
+                if (!Array.isArray(types)) types = [types];
+                if (!startPosition) startPosition = ZERO_POINT;
+                if (!endPosition) endPosition = ZERO_POINT;
+                const symbols = [];
+                const typesBySymbol = this.tree.language.types;
+                for (let i2 = 0, n = typesBySymbol.length; i2 < n; i2++) {
+                  if (types.includes(typesBySymbol[i2])) {
+                    symbols.push(i2);
+                  }
+                }
+                const symbolsAddress = C._malloc(SIZE_OF_INT * symbols.length);
+                for (let i2 = 0, n = symbols.length; i2 < n; i2++) {
+                  setValue(symbolsAddress + i2 * SIZE_OF_INT, symbols[i2], "i32");
+                }
+                marshalNode(this);
+                C._ts_node_descendants_of_type_wasm(this.tree[0], symbolsAddress, symbols.length, startPosition.row, startPosition.column, endPosition.row, endPosition.column);
+                const descendantCount = getValue(TRANSFER_BUFFER, "i32");
+                const descendantAddress = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                const result = new Array(descendantCount);
+                if (descendantCount > 0) {
+                  let address = descendantAddress;
+                  for (let i2 = 0; i2 < descendantCount; i2++) {
+                    result[i2] = unmarshalNode(this.tree, address);
+                    address += SIZE_OF_NODE;
+                  }
+                }
+                C._free(descendantAddress);
+                C._free(symbolsAddress);
+                return result;
+              }
+              get nextSibling() {
+                marshalNode(this);
+                C._ts_node_next_sibling_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              get previousSibling() {
+                marshalNode(this);
+                C._ts_node_prev_sibling_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              get nextNamedSibling() {
+                marshalNode(this);
+                C._ts_node_next_named_sibling_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              get previousNamedSibling() {
+                marshalNode(this);
+                C._ts_node_prev_named_sibling_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              get descendantCount() {
+                marshalNode(this);
+                return C._ts_node_descendant_count_wasm(this.tree[0]);
+              }
+              get parent() {
+                marshalNode(this);
+                C._ts_node_parent_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              descendantForIndex(start2, end = start2) {
+                if (typeof start2 !== "number" || typeof end !== "number") {
+                  throw new Error("Arguments must be numbers");
+                }
+                marshalNode(this);
+                const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+                setValue(address, start2, "i32");
+                setValue(address + SIZE_OF_INT, end, "i32");
+                C._ts_node_descendant_for_index_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              namedDescendantForIndex(start2, end = start2) {
+                if (typeof start2 !== "number" || typeof end !== "number") {
+                  throw new Error("Arguments must be numbers");
+                }
+                marshalNode(this);
+                const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+                setValue(address, start2, "i32");
+                setValue(address + SIZE_OF_INT, end, "i32");
+                C._ts_node_named_descendant_for_index_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              descendantForPosition(start2, end = start2) {
+                if (!isPoint(start2) || !isPoint(end)) {
+                  throw new Error("Arguments must be {row, column} objects");
+                }
+                marshalNode(this);
+                const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+                marshalPoint(address, start2);
+                marshalPoint(address + SIZE_OF_POINT, end);
+                C._ts_node_descendant_for_position_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              namedDescendantForPosition(start2, end = start2) {
+                if (!isPoint(start2) || !isPoint(end)) {
+                  throw new Error("Arguments must be {row, column} objects");
+                }
+                marshalNode(this);
+                const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+                marshalPoint(address, start2);
+                marshalPoint(address + SIZE_OF_POINT, end);
+                C._ts_node_named_descendant_for_position_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              walk() {
+                marshalNode(this);
+                C._ts_tree_cursor_new_wasm(this.tree[0]);
+                return new TreeCursor(INTERNAL, this.tree);
+              }
+              toString() {
+                marshalNode(this);
+                const address = C._ts_node_to_string_wasm(this.tree[0]);
+                const result = AsciiToString(address);
+                C._free(address);
+                return result;
+              }
+            }
+            class TreeCursor {
+              static {
+                __name(this, "TreeCursor");
+              }
+              constructor(internal, tree) {
+                assertInternal(internal);
+                this.tree = tree;
+                unmarshalTreeCursor(this);
+              }
+              delete() {
+                marshalTreeCursor(this);
+                C._ts_tree_cursor_delete_wasm(this.tree[0]);
+                this[0] = this[1] = this[2] = 0;
+              }
+              reset(node) {
+                marshalNode(node);
+                marshalTreeCursor(this, TRANSFER_BUFFER + SIZE_OF_NODE);
+                C._ts_tree_cursor_reset_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+              }
+              resetTo(cursor) {
+                marshalTreeCursor(this, TRANSFER_BUFFER);
+                marshalTreeCursor(cursor, TRANSFER_BUFFER + SIZE_OF_CURSOR);
+                C._ts_tree_cursor_reset_to_wasm(this.tree[0], cursor.tree[0]);
+                unmarshalTreeCursor(this);
+              }
+              get nodeType() {
+                return this.tree.language.types[this.nodeTypeId] || "ERROR";
+              }
+              get nodeTypeId() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_node_type_id_wasm(this.tree[0]);
+              }
+              get nodeStateId() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_node_state_id_wasm(this.tree[0]);
+              }
+              get nodeId() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_node_id_wasm(this.tree[0]);
+              }
+              get nodeIsNamed() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_node_is_named_wasm(this.tree[0]) === 1;
+              }
+              get nodeIsMissing() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_node_is_missing_wasm(this.tree[0]) === 1;
+              }
+              get nodeText() {
+                marshalTreeCursor(this);
+                const startIndex = C._ts_tree_cursor_start_index_wasm(this.tree[0]);
+                const endIndex = C._ts_tree_cursor_end_index_wasm(this.tree[0]);
+                return getText(this.tree, startIndex, endIndex);
+              }
+              get startPosition() {
+                marshalTreeCursor(this);
+                C._ts_tree_cursor_start_position_wasm(this.tree[0]);
+                return unmarshalPoint(TRANSFER_BUFFER);
+              }
+              get endPosition() {
+                marshalTreeCursor(this);
+                C._ts_tree_cursor_end_position_wasm(this.tree[0]);
+                return unmarshalPoint(TRANSFER_BUFFER);
+              }
+              get startIndex() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_start_index_wasm(this.tree[0]);
+              }
+              get endIndex() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_end_index_wasm(this.tree[0]);
+              }
+              get currentNode() {
+                marshalTreeCursor(this);
+                C._ts_tree_cursor_current_node_wasm(this.tree[0]);
+                return unmarshalNode(this.tree);
+              }
+              get currentFieldId() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_field_id_wasm(this.tree[0]);
+              }
+              get currentFieldName() {
+                return this.tree.language.fields[this.currentFieldId];
+              }
+              get currentDepth() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_depth_wasm(this.tree[0]);
+              }
+              get currentDescendantIndex() {
+                marshalTreeCursor(this);
+                return C._ts_tree_cursor_current_descendant_index_wasm(this.tree[0]);
+              }
+              gotoFirstChild() {
+                marshalTreeCursor(this);
+                const result = C._ts_tree_cursor_goto_first_child_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+                return result === 1;
+              }
+              gotoLastChild() {
+                marshalTreeCursor(this);
+                const result = C._ts_tree_cursor_goto_last_child_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+                return result === 1;
+              }
+              gotoFirstChildForIndex(goalIndex) {
+                marshalTreeCursor(this);
+                setValue(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalIndex, "i32");
+                const result = C._ts_tree_cursor_goto_first_child_for_index_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+                return result === 1;
+              }
+              gotoFirstChildForPosition(goalPosition) {
+                marshalTreeCursor(this);
+                marshalPoint(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalPosition);
+                const result = C._ts_tree_cursor_goto_first_child_for_position_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+                return result === 1;
+              }
+              gotoNextSibling() {
+                marshalTreeCursor(this);
+                const result = C._ts_tree_cursor_goto_next_sibling_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+                return result === 1;
+              }
+              gotoPreviousSibling() {
+                marshalTreeCursor(this);
+                const result = C._ts_tree_cursor_goto_previous_sibling_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+                return result === 1;
+              }
+              gotoDescendant(goalDescendantindex) {
+                marshalTreeCursor(this);
+                C._ts_tree_cursor_goto_descendant_wasm(this.tree[0], goalDescendantindex);
+                unmarshalTreeCursor(this);
+              }
+              gotoParent() {
+                marshalTreeCursor(this);
+                const result = C._ts_tree_cursor_goto_parent_wasm(this.tree[0]);
+                unmarshalTreeCursor(this);
+                return result === 1;
+              }
+            }
+            class Language {
+              static {
+                __name(this, "Language");
+              }
+              constructor(internal, address) {
+                assertInternal(internal);
+                this[0] = address;
+                this.types = new Array(C._ts_language_symbol_count(this[0]));
+                for (let i2 = 0, n = this.types.length; i2 < n; i2++) {
+                  if (C._ts_language_symbol_type(this[0], i2) < 2) {
+                    this.types[i2] = UTF8ToString(C._ts_language_symbol_name(this[0], i2));
+                  }
+                }
+                this.fields = new Array(C._ts_language_field_count(this[0]) + 1);
+                for (let i2 = 0, n = this.fields.length; i2 < n; i2++) {
+                  const fieldName = C._ts_language_field_name_for_id(this[0], i2);
+                  if (fieldName !== 0) {
+                    this.fields[i2] = UTF8ToString(fieldName);
+                  } else {
+                    this.fields[i2] = null;
+                  }
+                }
+              }
+              get version() {
+                return C._ts_language_version(this[0]);
+              }
+              get fieldCount() {
+                return this.fields.length - 1;
+              }
+              get stateCount() {
+                return C._ts_language_state_count(this[0]);
+              }
+              fieldIdForName(fieldName) {
+                const result = this.fields.indexOf(fieldName);
+                if (result !== -1) {
+                  return result;
+                } else {
+                  return null;
+                }
+              }
+              fieldNameForId(fieldId) {
+                return this.fields[fieldId] || null;
+              }
+              idForNodeType(type, named) {
+                const typeLength = lengthBytesUTF8(type);
+                const typeAddress = C._malloc(typeLength + 1);
+                stringToUTF8(type, typeAddress, typeLength + 1);
+                const result = C._ts_language_symbol_for_name(this[0], typeAddress, typeLength, named);
+                C._free(typeAddress);
+                return result || null;
+              }
+              get nodeTypeCount() {
+                return C._ts_language_symbol_count(this[0]);
+              }
+              nodeTypeForId(typeId) {
+                const name2 = C._ts_language_symbol_name(this[0], typeId);
+                return name2 ? UTF8ToString(name2) : null;
+              }
+              nodeTypeIsNamed(typeId) {
+                return C._ts_language_type_is_named_wasm(this[0], typeId) ? true : false;
+              }
+              nodeTypeIsVisible(typeId) {
+                return C._ts_language_type_is_visible_wasm(this[0], typeId) ? true : false;
+              }
+              nextState(stateId, typeId) {
+                return C._ts_language_next_state(this[0], stateId, typeId);
+              }
+              lookaheadIterator(stateId) {
+                const address = C._ts_lookahead_iterator_new(this[0], stateId);
+                if (address) return new LookaheadIterable(INTERNAL, address, this);
+                return null;
+              }
+              query(source) {
+                const sourceLength = lengthBytesUTF8(source);
+                const sourceAddress = C._malloc(sourceLength + 1);
+                stringToUTF8(source, sourceAddress, sourceLength + 1);
+                const address = C._ts_query_new(this[0], sourceAddress, sourceLength, TRANSFER_BUFFER, TRANSFER_BUFFER + SIZE_OF_INT);
+                if (!address) {
+                  const errorId = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                  const errorByte = getValue(TRANSFER_BUFFER, "i32");
+                  const errorIndex = UTF8ToString(sourceAddress, errorByte).length;
+                  const suffix = source.substr(errorIndex, 100).split("\n")[0];
+                  let word = suffix.match(QUERY_WORD_REGEX)[0];
+                  let error;
+                  switch (errorId) {
+                    case 2:
+                      error = new RangeError(`Bad node name '${word}'`);
+                      break;
+                    case 3:
+                      error = new RangeError(`Bad field name '${word}'`);
+                      break;
+                    case 4:
+                      error = new RangeError(`Bad capture name @${word}`);
+                      break;
+                    case 5:
+                      error = new TypeError(`Bad pattern structure at offset ${errorIndex}: '${suffix}'...`);
+                      word = "";
+                      break;
+                    default:
+                      error = new SyntaxError(`Bad syntax at offset ${errorIndex}: '${suffix}'...`);
+                      word = "";
+                      break;
+                  }
+                  error.index = errorIndex;
+                  error.length = word.length;
+                  C._free(sourceAddress);
+                  throw error;
+                }
+                const stringCount = C._ts_query_string_count(address);
+                const captureCount = C._ts_query_capture_count(address);
+                const patternCount = C._ts_query_pattern_count(address);
+                const captureNames = new Array(captureCount);
+                const stringValues = new Array(stringCount);
+                for (let i2 = 0; i2 < captureCount; i2++) {
+                  const nameAddress = C._ts_query_capture_name_for_id(address, i2, TRANSFER_BUFFER);
+                  const nameLength = getValue(TRANSFER_BUFFER, "i32");
+                  captureNames[i2] = UTF8ToString(nameAddress, nameLength);
+                }
+                for (let i2 = 0; i2 < stringCount; i2++) {
+                  const valueAddress = C._ts_query_string_value_for_id(address, i2, TRANSFER_BUFFER);
+                  const nameLength = getValue(TRANSFER_BUFFER, "i32");
+                  stringValues[i2] = UTF8ToString(valueAddress, nameLength);
+                }
+                const setProperties = new Array(patternCount);
+                const assertedProperties = new Array(patternCount);
+                const refutedProperties = new Array(patternCount);
+                const predicates = new Array(patternCount);
+                const textPredicates = new Array(patternCount);
+                for (let i2 = 0; i2 < patternCount; i2++) {
+                  const predicatesAddress = C._ts_query_predicates_for_pattern(address, i2, TRANSFER_BUFFER);
+                  const stepCount = getValue(TRANSFER_BUFFER, "i32");
+                  predicates[i2] = [];
+                  textPredicates[i2] = [];
+                  const steps = [];
+                  let stepAddress = predicatesAddress;
+                  for (let j = 0; j < stepCount; j++) {
+                    const stepType = getValue(stepAddress, "i32");
+                    stepAddress += SIZE_OF_INT;
+                    const stepValueId = getValue(stepAddress, "i32");
+                    stepAddress += SIZE_OF_INT;
+                    if (stepType === PREDICATE_STEP_TYPE_CAPTURE) {
+                      steps.push({
+                        type: "capture",
+                        name: captureNames[stepValueId]
+                      });
+                    } else if (stepType === PREDICATE_STEP_TYPE_STRING) {
+                      steps.push({
+                        type: "string",
+                        value: stringValues[stepValueId]
+                      });
+                    } else if (steps.length > 0) {
+                      if (steps[0].type !== "string") {
+                        throw new Error("Predicates must begin with a literal value");
+                      }
+                      const operator = steps[0].value;
+                      let isPositive = true;
+                      let matchAll = true;
+                      let captureName;
+                      switch (operator) {
+                        case "any-not-eq?":
+                        case "not-eq?":
+                          isPositive = false;
+                        case "any-eq?":
+                        case "eq?":
+                          if (steps.length !== 3) {
+                            throw new Error(`Wrong number of arguments to \`#${operator}\` predicate. Expected 2, got ${steps.length - 1}`);
+                          }
+                          if (steps[1].type !== "capture") {
+                            throw new Error(`First argument of \`#${operator}\` predicate must be a capture. Got "${steps[1].value}"`);
+                          }
+                          matchAll = !operator.startsWith("any-");
+                          if (steps[2].type === "capture") {
+                            const captureName1 = steps[1].name;
+                            const captureName2 = steps[2].name;
+                            textPredicates[i2].push((captures) => {
+                              const nodes1 = [];
+                              const nodes2 = [];
+                              for (const c of captures) {
+                                if (c.name === captureName1) nodes1.push(c.node);
+                                if (c.name === captureName2) nodes2.push(c.node);
+                              }
+                              const compare = /* @__PURE__ */ __name((n1, n2, positive) => positive ? n1.text === n2.text : n1.text !== n2.text, "compare");
+                              return matchAll ? nodes1.every((n1) => nodes2.some((n2) => compare(n1, n2, isPositive))) : nodes1.some((n1) => nodes2.some((n2) => compare(n1, n2, isPositive)));
+                            });
+                          } else {
+                            captureName = steps[1].name;
+                            const stringValue = steps[2].value;
+                            const matches = /* @__PURE__ */ __name((n) => n.text === stringValue, "matches");
+                            const doesNotMatch = /* @__PURE__ */ __name((n) => n.text !== stringValue, "doesNotMatch");
+                            textPredicates[i2].push((captures) => {
+                              const nodes = [];
+                              for (const c of captures) {
+                                if (c.name === captureName) nodes.push(c.node);
+                              }
+                              const test = isPositive ? matches : doesNotMatch;
+                              return matchAll ? nodes.every(test) : nodes.some(test);
+                            });
+                          }
+                          break;
+                        case "any-not-match?":
+                        case "not-match?":
+                          isPositive = false;
+                        case "any-match?":
+                        case "match?":
+                          if (steps.length !== 3) {
+                            throw new Error(`Wrong number of arguments to \`#${operator}\` predicate. Expected 2, got ${steps.length - 1}.`);
+                          }
+                          if (steps[1].type !== "capture") {
+                            throw new Error(`First argument of \`#${operator}\` predicate must be a capture. Got "${steps[1].value}".`);
+                          }
+                          if (steps[2].type !== "string") {
+                            throw new Error(`Second argument of \`#${operator}\` predicate must be a string. Got @${steps[2].value}.`);
+                          }
+                          captureName = steps[1].name;
+                          const regex = new RegExp(steps[2].value);
+                          matchAll = !operator.startsWith("any-");
+                          textPredicates[i2].push((captures) => {
+                            const nodes = [];
+                            for (const c of captures) {
+                              if (c.name === captureName) nodes.push(c.node.text);
+                            }
+                            const test = /* @__PURE__ */ __name((text, positive) => positive ? regex.test(text) : !regex.test(text), "test");
+                            if (nodes.length === 0) return !isPositive;
+                            return matchAll ? nodes.every((text) => test(text, isPositive)) : nodes.some((text) => test(text, isPositive));
+                          });
+                          break;
+                        case "set!":
+                          if (steps.length < 2 || steps.length > 3) {
+                            throw new Error(`Wrong number of arguments to \`#set!\` predicate. Expected 1 or 2. Got ${steps.length - 1}.`);
+                          }
+                          if (steps.some((s) => s.type !== "string")) {
+                            throw new Error(`Arguments to \`#set!\` predicate must be a strings.".`);
+                          }
+                          if (!setProperties[i2]) setProperties[i2] = {};
+                          setProperties[i2][steps[1].value] = steps[2] ? steps[2].value : null;
+                          break;
+                        case "is?":
+                        case "is-not?":
+                          if (steps.length < 2 || steps.length > 3) {
+                            throw new Error(`Wrong number of arguments to \`#${operator}\` predicate. Expected 1 or 2. Got ${steps.length - 1}.`);
+                          }
+                          if (steps.some((s) => s.type !== "string")) {
+                            throw new Error(`Arguments to \`#${operator}\` predicate must be a strings.".`);
+                          }
+                          const properties = operator === "is?" ? assertedProperties : refutedProperties;
+                          if (!properties[i2]) properties[i2] = {};
+                          properties[i2][steps[1].value] = steps[2] ? steps[2].value : null;
+                          break;
+                        case "not-any-of?":
+                          isPositive = false;
+                        case "any-of?":
+                          if (steps.length < 2) {
+                            throw new Error(`Wrong number of arguments to \`#${operator}\` predicate. Expected at least 1. Got ${steps.length - 1}.`);
+                          }
+                          if (steps[1].type !== "capture") {
+                            throw new Error(`First argument of \`#${operator}\` predicate must be a capture. Got "${steps[1].value}".`);
+                          }
+                          for (let i3 = 2; i3 < steps.length; i3++) {
+                            if (steps[i3].type !== "string") {
+                              throw new Error(`Arguments to \`#${operator}\` predicate must be a strings.".`);
+                            }
+                          }
+                          captureName = steps[1].name;
+                          const values = steps.slice(2).map((s) => s.value);
+                          textPredicates[i2].push((captures) => {
+                            const nodes = [];
+                            for (const c of captures) {
+                              if (c.name === captureName) nodes.push(c.node.text);
+                            }
+                            if (nodes.length === 0) return !isPositive;
+                            return nodes.every((text) => values.includes(text)) === isPositive;
+                          });
+                          break;
+                        default:
+                          predicates[i2].push({
+                            operator,
+                            operands: steps.slice(1)
+                          });
+                      }
+                      steps.length = 0;
+                    }
+                  }
+                  Object.freeze(setProperties[i2]);
+                  Object.freeze(assertedProperties[i2]);
+                  Object.freeze(refutedProperties[i2]);
+                }
+                C._free(sourceAddress);
+                return new Query(INTERNAL, address, captureNames, textPredicates, predicates, Object.freeze(setProperties), Object.freeze(assertedProperties), Object.freeze(refutedProperties));
+              }
+              static load(input) {
+                let bytes;
+                if (input instanceof Uint8Array) {
+                  bytes = Promise.resolve(input);
+                } else {
+                  const url = input;
+                  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+                    const fs2 = __require("fs");
+                    bytes = Promise.resolve(fs2.readFileSync(url));
+                  } else {
+                    bytes = fetch(url).then((response) => response.arrayBuffer().then((buffer) => {
+                      if (response.ok) {
+                        return new Uint8Array(buffer);
+                      } else {
+                        const body2 = new TextDecoder("utf-8").decode(buffer);
+                        throw new Error(`Language.load failed with status ${response.status}.
+
+${body2}`);
+                      }
+                    }));
+                  }
+                }
+                return bytes.then((bytes2) => loadWebAssemblyModule(bytes2, {
+                  loadAsync: true
+                })).then((mod) => {
+                  const symbolNames = Object.keys(mod);
+                  const functionName = symbolNames.find((key) => LANGUAGE_FUNCTION_REGEX.test(key) && !key.includes("external_scanner_"));
+                  if (!functionName) {
+                    console.log(`Couldn't find language function in WASM file. Symbols:
+${JSON.stringify(symbolNames, null, 2)}`);
+                  }
+                  const languageAddress = mod[functionName]();
+                  return new Language(INTERNAL, languageAddress);
+                });
+              }
+            }
+            class LookaheadIterable {
+              static {
+                __name(this, "LookaheadIterable");
+              }
+              constructor(internal, address, language) {
+                assertInternal(internal);
+                this[0] = address;
+                this.language = language;
+              }
+              get currentTypeId() {
+                return C._ts_lookahead_iterator_current_symbol(this[0]);
+              }
+              get currentType() {
+                return this.language.types[this.currentTypeId] || "ERROR";
+              }
+              delete() {
+                C._ts_lookahead_iterator_delete(this[0]);
+                this[0] = 0;
+              }
+              resetState(stateId) {
+                return C._ts_lookahead_iterator_reset_state(this[0], stateId);
+              }
+              reset(language, stateId) {
+                if (C._ts_lookahead_iterator_reset(this[0], language[0], stateId)) {
+                  this.language = language;
+                  return true;
+                }
+                return false;
+              }
+              [Symbol.iterator]() {
+                const self2 = this;
+                return {
+                  next() {
+                    if (C._ts_lookahead_iterator_next(self2[0])) {
+                      return {
+                        done: false,
+                        value: self2.currentType
+                      };
+                    }
+                    return {
+                      done: true,
+                      value: ""
+                    };
+                  }
+                };
+              }
+            }
+            class Query {
+              static {
+                __name(this, "Query");
+              }
+              constructor(internal, address, captureNames, textPredicates, predicates, setProperties, assertedProperties, refutedProperties) {
+                assertInternal(internal);
+                this[0] = address;
+                this.captureNames = captureNames;
+                this.textPredicates = textPredicates;
+                this.predicates = predicates;
+                this.setProperties = setProperties;
+                this.assertedProperties = assertedProperties;
+                this.refutedProperties = refutedProperties;
+                this.exceededMatchLimit = false;
+              }
+              delete() {
+                C._ts_query_delete(this[0]);
+                this[0] = 0;
+              }
+              matches(node, { startPosition = ZERO_POINT, endPosition = ZERO_POINT, startIndex = 0, endIndex = 0, matchLimit = 4294967295, maxStartDepth = 4294967295, timeoutMicros = 0 } = {}) {
+                if (typeof matchLimit !== "number") {
+                  throw new Error("Arguments must be numbers");
+                }
+                marshalNode(node);
+                C._ts_query_matches_wasm(this[0], node.tree[0], startPosition.row, startPosition.column, endPosition.row, endPosition.column, startIndex, endIndex, matchLimit, maxStartDepth, timeoutMicros);
+                const rawCount = getValue(TRANSFER_BUFFER, "i32");
+                const startAddress = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                const didExceedMatchLimit = getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, "i32");
+                const result = new Array(rawCount);
+                this.exceededMatchLimit = Boolean(didExceedMatchLimit);
+                let filteredCount = 0;
+                let address = startAddress;
+                for (let i2 = 0; i2 < rawCount; i2++) {
+                  const pattern = getValue(address, "i32");
+                  address += SIZE_OF_INT;
+                  const captureCount = getValue(address, "i32");
+                  address += SIZE_OF_INT;
+                  const captures = new Array(captureCount);
+                  address = unmarshalCaptures(this, node.tree, address, captures);
+                  if (this.textPredicates[pattern].every((p) => p(captures))) {
+                    result[filteredCount] = {
+                      pattern,
+                      captures
+                    };
+                    const setProperties = this.setProperties[pattern];
+                    if (setProperties) result[filteredCount].setProperties = setProperties;
+                    const assertedProperties = this.assertedProperties[pattern];
+                    if (assertedProperties) result[filteredCount].assertedProperties = assertedProperties;
+                    const refutedProperties = this.refutedProperties[pattern];
+                    if (refutedProperties) result[filteredCount].refutedProperties = refutedProperties;
+                    filteredCount++;
+                  }
+                }
+                result.length = filteredCount;
+                C._free(startAddress);
+                return result;
+              }
+              captures(node, { startPosition = ZERO_POINT, endPosition = ZERO_POINT, startIndex = 0, endIndex = 0, matchLimit = 4294967295, maxStartDepth = 4294967295, timeoutMicros = 0 } = {}) {
+                if (typeof matchLimit !== "number") {
+                  throw new Error("Arguments must be numbers");
+                }
+                marshalNode(node);
+                C._ts_query_captures_wasm(this[0], node.tree[0], startPosition.row, startPosition.column, endPosition.row, endPosition.column, startIndex, endIndex, matchLimit, maxStartDepth, timeoutMicros);
+                const count = getValue(TRANSFER_BUFFER, "i32");
+                const startAddress = getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+                const didExceedMatchLimit = getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, "i32");
+                const result = [];
+                this.exceededMatchLimit = Boolean(didExceedMatchLimit);
+                const captures = [];
+                let address = startAddress;
+                for (let i2 = 0; i2 < count; i2++) {
+                  const pattern = getValue(address, "i32");
+                  address += SIZE_OF_INT;
+                  const captureCount = getValue(address, "i32");
+                  address += SIZE_OF_INT;
+                  const captureIndex = getValue(address, "i32");
+                  address += SIZE_OF_INT;
+                  captures.length = captureCount;
+                  address = unmarshalCaptures(this, node.tree, address, captures);
+                  if (this.textPredicates[pattern].every((p) => p(captures))) {
+                    const capture = captures[captureIndex];
+                    const setProperties = this.setProperties[pattern];
+                    if (setProperties) capture.setProperties = setProperties;
+                    const assertedProperties = this.assertedProperties[pattern];
+                    if (assertedProperties) capture.assertedProperties = assertedProperties;
+                    const refutedProperties = this.refutedProperties[pattern];
+                    if (refutedProperties) capture.refutedProperties = refutedProperties;
+                    result.push(capture);
+                  }
+                }
+                C._free(startAddress);
+                return result;
+              }
+              predicatesForPattern(patternIndex) {
+                return this.predicates[patternIndex];
+              }
+              disableCapture(captureName) {
+                const captureNameLength = lengthBytesUTF8(captureName);
+                const captureNameAddress = C._malloc(captureNameLength + 1);
+                stringToUTF8(captureName, captureNameAddress, captureNameLength + 1);
+                C._ts_query_disable_capture(this[0], captureNameAddress, captureNameLength);
+                C._free(captureNameAddress);
+              }
+              didExceedMatchLimit() {
+                return this.exceededMatchLimit;
+              }
+            }
+            function getText(tree, startIndex, endIndex) {
+              const length = endIndex - startIndex;
+              let result = tree.textCallback(startIndex, null, endIndex);
+              startIndex += result.length;
+              while (startIndex < endIndex) {
+                const string = tree.textCallback(startIndex, null, endIndex);
+                if (string && string.length > 0) {
+                  startIndex += string.length;
+                  result += string;
+                } else {
+                  break;
+                }
+              }
+              if (startIndex > endIndex) {
+                result = result.slice(0, length);
+              }
+              return result;
+            }
+            __name(getText, "getText");
+            function unmarshalCaptures(query, tree, address, result) {
+              for (let i2 = 0, n = result.length; i2 < n; i2++) {
+                const captureIndex = getValue(address, "i32");
+                address += SIZE_OF_INT;
+                const node = unmarshalNode(tree, address);
+                address += SIZE_OF_NODE;
+                result[i2] = {
+                  name: query.captureNames[captureIndex],
+                  node
+                };
+              }
+              return address;
+            }
+            __name(unmarshalCaptures, "unmarshalCaptures");
+            function assertInternal(x) {
+              if (x !== INTERNAL) throw new Error("Illegal constructor");
+            }
+            __name(assertInternal, "assertInternal");
+            function isPoint(point) {
+              return point && typeof point.row === "number" && typeof point.column === "number";
+            }
+            __name(isPoint, "isPoint");
+            function marshalNode(node) {
+              let address = TRANSFER_BUFFER;
+              setValue(address, node.id, "i32");
+              address += SIZE_OF_INT;
+              setValue(address, node.startIndex, "i32");
+              address += SIZE_OF_INT;
+              setValue(address, node.startPosition.row, "i32");
+              address += SIZE_OF_INT;
+              setValue(address, node.startPosition.column, "i32");
+              address += SIZE_OF_INT;
+              setValue(address, node[0], "i32");
+            }
+            __name(marshalNode, "marshalNode");
+            function unmarshalNode(tree, address = TRANSFER_BUFFER) {
+              const id = getValue(address, "i32");
+              address += SIZE_OF_INT;
+              if (id === 0) return null;
+              const index = getValue(address, "i32");
+              address += SIZE_OF_INT;
+              const row = getValue(address, "i32");
+              address += SIZE_OF_INT;
+              const column = getValue(address, "i32");
+              address += SIZE_OF_INT;
+              const other = getValue(address, "i32");
+              const result = new Node(INTERNAL, tree);
+              result.id = id;
+              result.startIndex = index;
+              result.startPosition = {
+                row,
+                column
+              };
+              result[0] = other;
+              return result;
+            }
+            __name(unmarshalNode, "unmarshalNode");
+            function marshalTreeCursor(cursor, address = TRANSFER_BUFFER) {
+              setValue(address + 0 * SIZE_OF_INT, cursor[0], "i32");
+              setValue(address + 1 * SIZE_OF_INT, cursor[1], "i32");
+              setValue(address + 2 * SIZE_OF_INT, cursor[2], "i32");
+              setValue(address + 3 * SIZE_OF_INT, cursor[3], "i32");
+            }
+            __name(marshalTreeCursor, "marshalTreeCursor");
+            function unmarshalTreeCursor(cursor) {
+              cursor[0] = getValue(TRANSFER_BUFFER + 0 * SIZE_OF_INT, "i32");
+              cursor[1] = getValue(TRANSFER_BUFFER + 1 * SIZE_OF_INT, "i32");
+              cursor[2] = getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, "i32");
+              cursor[3] = getValue(TRANSFER_BUFFER + 3 * SIZE_OF_INT, "i32");
+            }
+            __name(unmarshalTreeCursor, "unmarshalTreeCursor");
+            function marshalPoint(address, point) {
+              setValue(address, point.row, "i32");
+              setValue(address + SIZE_OF_INT, point.column, "i32");
+            }
+            __name(marshalPoint, "marshalPoint");
+            function unmarshalPoint(address) {
+              const result = {
+                row: getValue(address, "i32") >>> 0,
+                column: getValue(address + SIZE_OF_INT, "i32") >>> 0
+              };
+              return result;
+            }
+            __name(unmarshalPoint, "unmarshalPoint");
+            function marshalRange(address, range) {
+              marshalPoint(address, range.startPosition);
+              address += SIZE_OF_POINT;
+              marshalPoint(address, range.endPosition);
+              address += SIZE_OF_POINT;
+              setValue(address, range.startIndex, "i32");
+              address += SIZE_OF_INT;
+              setValue(address, range.endIndex, "i32");
+              address += SIZE_OF_INT;
+            }
+            __name(marshalRange, "marshalRange");
+            function unmarshalRange(address) {
+              const result = {};
+              result.startPosition = unmarshalPoint(address);
+              address += SIZE_OF_POINT;
+              result.endPosition = unmarshalPoint(address);
+              address += SIZE_OF_POINT;
+              result.startIndex = getValue(address, "i32") >>> 0;
+              address += SIZE_OF_INT;
+              result.endIndex = getValue(address, "i32") >>> 0;
+              return result;
+            }
+            __name(unmarshalRange, "unmarshalRange");
+            function marshalEdit(edit) {
+              let address = TRANSFER_BUFFER;
+              marshalPoint(address, edit.startPosition);
+              address += SIZE_OF_POINT;
+              marshalPoint(address, edit.oldEndPosition);
+              address += SIZE_OF_POINT;
+              marshalPoint(address, edit.newEndPosition);
+              address += SIZE_OF_POINT;
+              setValue(address, edit.startIndex, "i32");
+              address += SIZE_OF_INT;
+              setValue(address, edit.oldEndIndex, "i32");
+              address += SIZE_OF_INT;
+              setValue(address, edit.newEndIndex, "i32");
+              address += SIZE_OF_INT;
+            }
+            __name(marshalEdit, "marshalEdit");
+            for (const name2 of Object.getOwnPropertyNames(ParserImpl.prototype)) {
+              Object.defineProperty(Parser.prototype, name2, {
+                value: ParserImpl.prototype[name2],
+                enumerable: false,
+                writable: false
+              });
+            }
+            Parser.Language = Language;
+            Module.onRuntimeInitialized = () => {
+              ParserImpl.init();
+              resolveInitPromise();
+            };
+          });
+        }
+      }
+      return Parser;
+    }();
+    if (typeof exports === "object") {
+      module.exports = TreeSitter;
+    }
+  }
+});
+export default require_tree_sitter();