oh-my-opencode 0.1.7 → 0.1.9

package/dist/index.js

@@ -1,16 +1,2905 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
+  for (var name2 in all)
+    __defProp(target, name2, {
+      get: all[name2],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: (newValue) => all[name2] = () => newValue
     });
 };
 var __require = import.meta.require;
 
+// node_modules/web-tree-sitter/tree-sitter.js
+var require_tree_sitter = __commonJS((exports, module2) => {
+  var __dirname = "/home/runner/work/oh-my-opencode/oh-my-opencode/node_modules/web-tree-sitter";
+  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 {
+      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_ = (status, toThrow) => {
+            throw toThrow;
+          };
+          var scriptDirectory = "";
+          function locateFile(path) {
+            if (Module["locateFile"]) {
+              return Module["locateFile"](path, scriptDirectory);
+            }
+            return scriptDirectory + path;
+          }
+          var readAsync, readBinary;
+          if (ENVIRONMENT_IS_NODE) {
+            var fs = __require("fs");
+            var nodePath = __require("path");
+            scriptDirectory = __dirname + "/";
+            readBinary = (filename) => {
+              filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+              var ret = fs.readFileSync(filename);
+              return ret;
+            };
+            readAsync = (filename, binary2 = true) => {
+              filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+              return new Promise((resolve, reject) => {
+                fs.readFile(filename, binary2 ? undefined : "utf8", (err2, data) => {
+                  if (err2)
+                    reject(err2);
+                  else
+                    resolve(binary2 ? data.buffer : data);
+                });
+              });
+            };
+            if (!Module["thisProgram"] && process.argv.length > 1) {
+              thisProgram = process.argv[1].replace(/\\/g, "/");
+            }
+            arguments_ = process.argv.slice(2);
+            if (typeof module2 != "undefined") {
+              module2["exports"] = Module;
+            }
+            quit_ = (status, toThrow) => {
+              process.exitCode = status;
+              throw toThrow;
+            };
+          } 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 = (url) => {
+                  var xhr = new XMLHttpRequest;
+                  xhr.open("GET", url, false);
+                  xhr.responseType = "arraybuffer";
+                  xhr.send(null);
+                  return new Uint8Array(xhr.response);
+                };
+              }
+              readAsync = (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));
+                });
+              };
+            }
+          } 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);
+          }
+          if (Module["wasmMemory"]) {
+            wasmMemory = Module["wasmMemory"];
+          } else {
+            var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 33554432;
+            wasmMemory = new WebAssembly.Memory({
+              initial: INITIAL_MEMORY / 65536,
+              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__);
+          }
+          function initRuntime() {
+            runtimeInitialized = true;
+            callRuntimeCallbacks(__RELOC_FUNCS__);
+            callRuntimeCallbacks(__ATINIT__);
+          }
+          function preMain() {
+            callRuntimeCallbacks(__ATMAIN__);
+          }
+          function postRun() {
+            if (Module["postRun"]) {
+              if (typeof Module["postRun"] == "function")
+                Module["postRun"] = [Module["postRun"]];
+              while (Module["postRun"].length) {
+                addOnPostRun(Module["postRun"].shift());
+              }
+            }
+            callRuntimeCallbacks(__ATPOSTRUN__);
+          }
+          function addOnPreRun(cb) {
+            __ATPRERUN__.unshift(cb);
+          }
+          function addOnInit(cb) {
+            __ATINIT__.unshift(cb);
+          }
+          function addOnPostRun(cb) {
+            __ATPOSTRUN__.unshift(cb);
+          }
+          var runDependencies = 0;
+          var runDependencyWatcher = null;
+          var dependenciesFulfilled = null;
+          function getUniqueRunDependency(id) {
+            return id;
+          }
+          function addRunDependency(id) {
+            runDependencies++;
+            Module["monitorRunDependencies"]?.(runDependencies);
+          }
+          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();
+              }
+            }
+          }
+          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;
+          }
+          var dataURIPrefix = "data:application/octet-stream;base64,";
+          var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
+          var isFileURI = (filename) => filename.startsWith("file://");
+          function findWasmBinary() {
+            var f = "tree-sitter.wasm";
+            if (!isDataURI(f)) {
+              return locateFile(f);
+            }
+            return f;
+          }
+          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";
+          }
+          function getBinaryPromise(binaryFile) {
+            if (!wasmBinary) {
+              return readAsync(binaryFile).then((response) => new Uint8Array(response), () => getBinarySync(binaryFile));
+            }
+            return Promise.resolve().then(() => getBinarySync(binaryFile));
+          }
+          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);
+            });
+          }
+          function instantiateAsync(binary2, binaryFile, imports, callback) {
+            if (!binary2 && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !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);
+          }
+          function getWasmImports() {
+            return {
+              env: wasmImports,
+              wasi_snapshot_preview1: wasmImports,
+              "GOT.mem": new Proxy(wasmImports, GOTHandler),
+              "GOT.func": new Proxy(wasmImports, GOTHandler)
+            };
+          }
+          function createWasm() {
+            var info2 = getWasmImports();
+            function receiveInstance(instance2, module3) {
+              wasmExports = instance2.exports;
+              wasmExports = relocateExports(wasmExports, 1024);
+              var metadata2 = getDylinkMetadata(module3);
+              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;
+            }
+            addRunDependency("wasm-instantiate");
+            function receiveInstantiationResult(result) {
+              receiveInstance(result["instance"], result["module"]);
+            }
+            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 {};
+          }
+          var ASM_CONSTS = {};
+          function ExitStatus(status) {
+            this.name = "ExitStatus";
+            this.message = `Program terminated with exit(${status})`;
+            this.status = status;
+          }
+          var GOT = {};
+          var currentModuleWeakSymbols = 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 = (byteOffset) => HEAP_DATA_VIEW.getFloat32(byteOffset, true);
+          var LE_HEAP_LOAD_F64 = (byteOffset) => HEAP_DATA_VIEW.getFloat64(byteOffset, true);
+          var LE_HEAP_LOAD_I16 = (byteOffset) => HEAP_DATA_VIEW.getInt16(byteOffset, true);
+          var LE_HEAP_LOAD_I32 = (byteOffset) => HEAP_DATA_VIEW.getInt32(byteOffset, true);
+          var LE_HEAP_LOAD_U32 = (byteOffset) => HEAP_DATA_VIEW.getUint32(byteOffset, true);
+          var LE_HEAP_STORE_F32 = (byteOffset, value) => HEAP_DATA_VIEW.setFloat32(byteOffset, value, true);
+          var LE_HEAP_STORE_F64 = (byteOffset, value) => HEAP_DATA_VIEW.setFloat64(byteOffset, value, true);
+          var LE_HEAP_STORE_I16 = (byteOffset, value) => HEAP_DATA_VIEW.setInt16(byteOffset, value, true);
+          var LE_HEAP_STORE_I32 = (byteOffset, value) => HEAP_DATA_VIEW.setInt32(byteOffset, value, true);
+          var LE_HEAP_STORE_U32 = (byteOffset, value) => HEAP_DATA_VIEW.setUint32(byteOffset, value, true);
+          var callRuntimeCallbacks = (callbacks) => {
+            while (callbacks.length > 0) {
+              callbacks.shift()(Module);
+            }
+          };
+          var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined;
+          var UTF8ArrayToString = (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;
+          };
+          var getDylinkMetadata = (binary2) => {
+            var offset = 0;
+            var end = 0;
+            function getU8() {
+              return binary2[offset++];
+            }
+            function getLEB() {
+              var ret = 0;
+              var mul = 1;
+              while (true) {
+                var byte = binary2[offset++];
+                ret += (byte & 127) * mul;
+                mul *= 128;
+                if (!(byte & 128))
+                  break;
+              }
+              return ret;
+            }
+            function getString() {
+              var len = getLEB();
+              offset += len;
+              return UTF8ArrayToString(binary2, offset - len, len);
+            }
+            function failIf(condition, message) {
+              if (condition)
+                throw new Error(message);
+            }
+            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: new Set,
+              weakImports: 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;
+          };
+          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}`);
+            }
+          }
+          var newDSO = (name2, handle2, syms) => {
+            var dso = {
+              refcount: Infinity,
+              name: name2,
+              exports: syms,
+              global: true
+            };
+            LDSO.loadedLibsByName[name2] = dso;
+            if (handle2 != null) {
+              LDSO.loadedLibsByHandle[handle2] = dso;
+            }
+            return dso;
+          };
+          var LDSO = {
+            loadedLibsByName: {},
+            loadedLibsByHandle: {},
+            init() {
+              newDSO("__main__", 0, wasmImports);
+            }
+          };
+          var ___heap_base = 78112;
+          var zeroMemory = (address, size) => {
+            HEAPU8.fill(0, address, address + size);
+            return address;
+          };
+          var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+          var getMemory = (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;
+          };
+          var isInternalSym = (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__");
+          var uleb128Encode = (n, target) => {
+            if (n < 128) {
+              target.push(n);
+            } else {
+              target.push(n % 128 | 128, n >> 7);
+            }
+          };
+          var sigToWasmTypes = (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;
+          };
+          var generateFuncType = (sig, target) => {
+            var sigRet = sig.slice(0, 1);
+            var sigParam = sig.slice(1);
+            var typeCodes = {
+              i: 127,
+              p: 127,
+              j: 126,
+              f: 125,
+              d: 124,
+              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]);
+            }
+          };
+          var convertJsFunctionToWasm = (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,
+              1,
+              0,
+              0,
+              0,
+              1
+            ];
+            uleb128Encode(typeSectionBody.length, bytes);
+            bytes.push(...typeSectionBody);
+            bytes.push(2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+            var module3 = new WebAssembly.Module(new Uint8Array(bytes));
+            var instance2 = new WebAssembly.Instance(module3, {
+              e: {
+                f: func2
+              }
+            });
+            var wrappedFunc = instance2.exports["f"];
+            return wrappedFunc;
+          };
+          var wasmTableMirror = [];
+          var wasmTable = new WebAssembly.Table({
+            initial: 28,
+            element: "anyfunc"
+          });
+          var getWasmTableEntry = (funcPtr) => {
+            var func2 = wasmTableMirror[funcPtr];
+            if (!func2) {
+              if (funcPtr >= wasmTableMirror.length)
+                wasmTableMirror.length = funcPtr + 1;
+              wasmTableMirror[funcPtr] = func2 = wasmTable.get(funcPtr);
+            }
+            return func2;
+          };
+          var updateTableMap = (offset, count) => {
+            if (functionsInTableMap) {
+              for (var i2 = offset;i2 < offset + count; i2++) {
+                var item = getWasmTableEntry(i2);
+                if (item) {
+                  functionsInTableMap.set(item, i2);
+                }
+              }
+            }
+          };
+          var functionsInTableMap;
+          var getFunctionAddress = (func2) => {
+            if (!functionsInTableMap) {
+              functionsInTableMap = new WeakMap;
+              updateTableMap(0, wasmTable.length);
+            }
+            return functionsInTableMap.get(func2) || 0;
+          };
+          var freeTableIndexes = [];
+          var getEmptyTableSlot = () => {
+            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;
+          };
+          var setWasmTableEntry = (idx, func2) => {
+            wasmTable.set(idx, func2);
+            wasmTableMirror[idx] = wasmTable.get(idx);
+          };
+          var addFunction = (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;
+          };
+          var updateGOT = (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}`);
+                }
+              }
+            }
+          };
+          var relocateExports = (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;
+          };
+          var isSymbolDefined = (symName) => {
+            var existing = wasmImports[symName];
+            if (!existing || existing.stub) {
+              return false;
+            }
+            return true;
+          };
+          var dynCallLegacy = (sig, ptr, args2) => {
+            sig = sig.replace(/p/g, "i");
+            var f = Module["dynCall_" + sig];
+            return f(ptr, ...args2);
+          };
+          var dynCall = (sig, ptr, args2 = []) => {
+            if (sig.includes("j")) {
+              return dynCallLegacy(sig, ptr, args2);
+            }
+            var rtn = getWasmTableEntry(ptr)(...args2);
+            return rtn;
+          };
+          var stackSave = () => _emscripten_stack_get_current();
+          var stackRestore = (val) => __emscripten_stack_restore(val);
+          var createInvokeFunction = (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);
+            }
+          };
+          var resolveGlobalSymbol = (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
+            };
+          };
+          var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+          var loadWebAssemblyModule = (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;
+              }
+              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);
+                }
+                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);
+                }
+                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;
+              }
+              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);
+            }
+            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();
+          };
+          var mergeLibSymbols = (exports2, libName2) => {
+            for (var [sym, exp] of Object.entries(exports2)) {
+              const setImport = (target) => {
+                if (!isSymbolDefined(target)) {
+                  wasmImports[target] = exp;
+                }
+              };
+              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;
+              }
+            }
+          };
+          var asyncLoad = (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);
+          };
+          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);
+            }
+            function getExports() {
+              if (flags2.loadAsync) {
+                return loadLibData().then((libData) => loadWebAssemblyModule(libData, flags2, libName2, localScope2, handle2));
+              }
+              return loadWebAssemblyModule(loadLibData(), flags2, libName2, localScope2, handle2);
+            }
+            function moduleLoaded(exports2) {
+              if (dso.global) {
+                mergeLibSymbols(exports2, libName2);
+              } else if (localScope2) {
+                Object.assign(localScope2, exports2);
+              }
+              dso.exports = exports2;
+            }
+            if (flags2.loadAsync) {
+              return getExports().then((exports2) => {
+                moduleLoaded(exports2);
+                return true;
+              });
+            }
+            moduleLoaded(getExports());
+            return true;
+          }
+          var reportUndefinedSymbols = () => {
+            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}`);
+                }
+              }
+            }
+          };
+          var loadDylibs = () => {
+            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");
+            });
+          };
+          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}`);
+            }
+          }
+          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 = () => {
+            abort("");
+          };
+          __abort_js.sig = "v";
+          var nowIsMonotonic = 1;
+          var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;
+          __emscripten_get_now_is_monotonic.sig = "i";
+          var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
+          __emscripten_memcpy_js.sig = "vppp";
+          var _emscripten_date_now = () => Date.now();
+          _emscripten_date_now.sig = "d";
+          var _emscripten_get_now;
+          _emscripten_get_now = () => performance.now();
+          _emscripten_get_now.sig = "d";
+          var getHeapMax = () => 2147483648;
+          var growMemory = (size) => {
+            var b = wasmMemory.buffer;
+            var pages = (size - b.byteLength + 65535) / 65536;
+            try {
+              wasmMemory.grow(pages);
+              updateMemoryViews();
+              return 1;
+            } catch (e) {}
+          };
+          var _emscripten_resize_heap = (requestedSize) => {
+            var oldSize = HEAPU8.length;
+            requestedSize >>>= 0;
+            var maxHeapSize = getHeapMax();
+            if (requestedSize > maxHeapSize) {
+              return false;
+            }
+            var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+            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.sig = "ip";
+          var _fd_close = (fd) => 52;
+          _fd_close.sig = "ii";
+          var convertI32PairToI53Checked = (lo, hi) => hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
+          function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+            var offset = convertI32PairToI53Checked(offset_low, offset_high);
+            return 70;
+          }
+          _fd_seek.sig = "iiiiip";
+          var printCharBuffers = [null, [], []];
+          var printChar = (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);
+            }
+          };
+          var _fd_write = (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.sig = "iippp";
+          function _tree_sitter_log_callback(isLexMessage, messageAddress) {
+            if (currentLogCallback) {
+              const message = UTF8ToString(messageAddress);
+              currentLogCallback(message, isLexMessage !== 0);
+            }
+          }
+          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");
+            }
+          }
+          var runtimeKeepaliveCounter = 0;
+          var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+          var _proc_exit = (code) => {
+            EXITSTATUS = code;
+            if (!keepRuntimeAlive()) {
+              Module["onExit"]?.(code);
+              ABORT = true;
+            }
+            quit_(code, new ExitStatus(code));
+          };
+          _proc_exit.sig = "vi";
+          var exitJS = (status, implicit) => {
+            EXITSTATUS = status;
+            _proc_exit(status);
+          };
+          var handleException = (e) => {
+            if (e instanceof ExitStatus || e == "unwind") {
+              return EXITSTATUS;
+            }
+            quit_(1, e);
+          };
+          var lengthBytesUTF8 = (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;
+          };
+          var stringToUTF8Array = (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;
+          };
+          var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+          var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+          var stringToUTF8OnStack = (str) => {
+            var size = lengthBytesUTF8(str) + 1;
+            var ret = stackAlloc(size);
+            stringToUTF8(str, ret, size);
+            return ret;
+          };
+          var stringToUTF16 = (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;
+          };
+          var AsciiToString = (ptr) => {
+            var str = "";
+            while (true) {
+              var ch = HEAPU8[ptr++];
+              if (!ch)
+                return str;
+              str += String.fromCharCode(ch);
+            }
+          };
+          var wasmImports = {
+            __heap_base: ___heap_base,
+            __indirect_function_table: wasmTable,
+            __memory_base: ___memory_base,
+            __stack_pointer: ___stack_pointer,
+            __table_base: ___table_base,
+            _abort_js: __abort_js,
+            _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
+            _emscripten_memcpy_js: __emscripten_memcpy_js,
+            emscripten_get_now: _emscripten_get_now,
+            emscripten_resize_heap: _emscripten_resize_heap,
+            fd_close: _fd_close,
+            fd_seek: _fd_seek,
+            fd_write: _fd_write,
+            memory: wasmMemory,
+            tree_sitter_log_callback: _tree_sitter_log_callback,
+            tree_sitter_parse_callback: _tree_sitter_parse_callback
+          };
+          var wasmExports = createWasm();
+          var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["__wasm_call_ctors"])();
+          var ___wasm_apply_data_relocs = () => (___wasm_apply_data_relocs = wasmExports["__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 = (a0, a1) => (_setThrew = wasmExports["setThrew"])(a0, a1);
+          var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);
+          var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);
+          var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["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 = function runCaller() {
+            if (!calledRun)
+              run();
+            if (!calledRun)
+              dependenciesFulfilled = 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, true);
+              return ret;
+            } catch (e) {
+              return handleException(e);
+            }
+          }
+          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();
+            }
+            if (Module["setStatus"]) {
+              Module["setStatus"]("Running...");
+              setTimeout(function() {
+                setTimeout(function() {
+                  Module["setStatus"]("");
+                }, 1);
+                doRun();
+              }, 1);
+            } else {
+              doRun();
+            }
+          }
+          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 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 = (index, _) => callback.slice(index);
+              } 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 {
+            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 {
+            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(types2, startPosition, endPosition) {
+              if (!Array.isArray(types2))
+                types2 = [types2];
+              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 (types2.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 {
+            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 {
+            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(`
+`)[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 = (n1, n2, positive) => positive ? n1.text === n2.text : n1.text !== n2.text;
+                            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 = (n) => n.text === stringValue;
+                          const doesNotMatch = (n) => n.text !== stringValue;
+                          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 = (text, positive) => positive ? regex.test(text) : !regex.test(text);
+                          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 {
+            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 {
+            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;
+          }
+          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;
+          }
+          function assertInternal(x) {
+            if (x !== INTERNAL)
+              throw new Error("Illegal constructor");
+          }
+          function isPoint(point) {
+            return point && typeof point.row === "number" && typeof point.column === "number";
+          }
+          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");
+          }
+          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;
+          }
+          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");
+          }
+          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");
+          }
+          function marshalPoint(address, point) {
+            setValue(address, point.row, "i32");
+            setValue(address + SIZE_OF_INT, point.column, "i32");
+          }
+          function unmarshalPoint(address) {
+            const result = {
+              row: getValue(address, "i32") >>> 0,
+              column: getValue(address + SIZE_OF_INT, "i32") >>> 0
+            };
+            return result;
+          }
+          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;
+          }
+          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;
+          }
+          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;
+          }
+          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") {
+    module2.exports = TreeSitter;
+  }
+});
+
 // src/agents/oracle.ts
 var oracleAgent = {
   description: "Expert AI advisor with advanced reasoning capabilities for high-quality technical guidance, code reviews, architectural advice, and strategic planning.",
@@ -587,16 +3476,16 @@ function mergeAgentConfig(base, override) {
 }
 function createBuiltinAgents(disabledAgents = [], agentOverrides = {}) {
   const result = {};
-  for (const [name, config] of Object.entries(allBuiltinAgents)) {
-    const agentName = name;
+  for (const [name2, config] of Object.entries(allBuiltinAgents)) {
+    const agentName = name2;
     if (disabledAgents.includes(agentName)) {
       continue;
     }
     const override = agentOverrides[agentName];
     if (override) {
-      result[name] = mergeAgentConfig(config, override);
+      result[name2] = mergeAgentConfig(config, override);
     } else {
-      result[name] = config;
+      result[name2] = config;
     }
   }
   return result;
@@ -619,11 +3508,11 @@ function detectInterrupt(error) {
     return false;
   if (typeof error === "object") {
     const errObj = error;
-    const name = errObj.name;
+    const name2 = errObj.name;
     const message = errObj.message?.toLowerCase() ?? "";
-    if (name === "MessageAbortedError" || name === "AbortError")
+    if (name2 === "MessageAbortedError" || name2 === "AbortError")
       return true;
-    if (name === "DOMException" && message.includes("abort"))
+    if (name2 === "DOMException" && message.includes("abort"))
       return true;
     if (message.includes("aborted") || message.includes("cancelled") || message.includes("interrupted"))
       return true;
@@ -705,9 +3594,9 @@ function createTodoContinuationEnforcer(ctx) {
       }
     }
     if (event.type === "message.updated") {
-      const info = props?.info;
-      const sessionID = info?.sessionID;
-      if (sessionID && info?.role === "user") {
+      const info2 = props?.info;
+      const sessionID = info2?.sessionID;
+      if (sessionID && info2?.role === "user") {
         remindedSessions.delete(sessionID);
       }
     }
@@ -814,12 +3703,12 @@ function detectErrorType(error) {
   }
   return null;
 }
-function extractToolUseIds(parts) {
-  return parts.filter((p) => p.type === "tool_use" && !!p.id).map((p) => p.id);
+function extractToolUseIds(parts2) {
+  return parts2.filter((p) => p.type === "tool_use" && !!p.id).map((p) => p.id);
 }
 async function recoverToolResultMissing(client, sessionID, failedAssistantMsg) {
-  const parts = failedAssistantMsg.parts || [];
-  const toolUseIds = extractToolUseIds(parts);
+  const parts2 = failedAssistantMsg.parts || [];
+  const toolUseIds = extractToolUseIds(parts2);
   if (toolUseIds.length === 0) {
     return false;
   }
@@ -926,9 +3815,9 @@ async function fallbackRevertStrategy(client, sessionID, failedAssistantMsg, dir
     targetUserMsg = msgs.find((m) => m.info?.id === parentMsgID) ?? null;
   }
   if (!targetUserMsg) {
-    for (let i = msgs.length - 1;i >= 0; i--) {
-      if (msgs[i].info?.role === "user") {
-        targetUserMsg = msgs[i];
+    for (let i2 = msgs.length - 1;i2 >= 0; i2--) {
+      if (msgs[i2].info?.role === "user") {
+        targetUserMsg = msgs[i2];
         break;
       }
     }
@@ -961,14 +3850,14 @@ function createSessionRecoveryHook(ctx) {
   const isRecoverableError = (error) => {
     return detectErrorType(error) !== null;
   };
-  const handleSessionRecovery = async (info) => {
-    if (!info || info.role !== "assistant" || !info.error)
+  const handleSessionRecovery = async (info2) => {
+    if (!info2 || info2.role !== "assistant" || !info2.error)
       return false;
-    const errorType = detectErrorType(info.error);
+    const errorType = detectErrorType(info2.error);
     if (!errorType)
       return false;
-    const sessionID = info.sessionID;
-    const assistantMsgID = info.id;
+    const sessionID = info2.sessionID;
+    const assistantMsgID = info2.id;
     if (!sessionID || !assistantMsgID)
       return false;
     if (processingErrors.has(assistantMsgID))
@@ -1034,6 +3923,115 @@ function createSessionRecoveryHook(ctx) {
   };
 }
 // src/hooks/comment-checker/constants.ts
+var EXTENSION_TO_LANGUAGE = {
+  py: "python",
+  js: "javascript",
+  jsx: "javascript",
+  ts: "typescript",
+  tsx: "tsx",
+  go: "golang",
+  java: "java",
+  kt: "kotlin",
+  scala: "scala",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  cc: "cpp",
+  cxx: "cpp",
+  hpp: "cpp",
+  rs: "rust",
+  rb: "ruby",
+  sh: "bash",
+  bash: "bash",
+  cs: "csharp",
+  swift: "swift",
+  ex: "elixir",
+  exs: "elixir",
+  lua: "lua",
+  php: "php",
+  ml: "ocaml",
+  mli: "ocaml",
+  sql: "sql",
+  html: "html",
+  htm: "html",
+  css: "css",
+  yaml: "yaml",
+  yml: "yaml",
+  toml: "toml",
+  hcl: "hcl",
+  tf: "hcl",
+  dockerfile: "dockerfile",
+  proto: "protobuf",
+  svelte: "svelte",
+  elm: "elm",
+  groovy: "groovy",
+  cue: "cue"
+};
+var QUERY_TEMPLATES = {
+  python: "(comment) @comment",
+  javascript: "(comment) @comment",
+  typescript: "(comment) @comment",
+  tsx: "(comment) @comment",
+  golang: "(comment) @comment",
+  rust: `
+    (line_comment) @comment
+    (block_comment) @comment
+  `,
+  kotlin: `
+    (line_comment) @comment
+    (multiline_comment) @comment
+  `,
+  java: `
+    (line_comment) @comment
+    (block_comment) @comment
+  `,
+  c: "(comment) @comment",
+  cpp: "(comment) @comment",
+  csharp: "(comment) @comment",
+  ruby: "(comment) @comment",
+  bash: "(comment) @comment",
+  swift: "(comment) @comment",
+  elixir: "(comment) @comment",
+  lua: "(comment) @comment",
+  php: "(comment) @comment",
+  ocaml: "(comment) @comment",
+  sql: "(comment) @comment",
+  html: "(comment) @comment",
+  css: "(comment) @comment",
+  yaml: "(comment) @comment",
+  toml: "(comment) @comment",
+  hcl: "(comment) @comment",
+  dockerfile: "(comment) @comment",
+  protobuf: "(comment) @comment",
+  svelte: "(comment) @comment",
+  elm: "(comment) @comment",
+  groovy: "(comment) @comment",
+  cue: "(comment) @comment",
+  scala: "(comment) @comment"
+};
+var DOCSTRING_QUERIES = {
+  python: `
+    (module . (expression_statement (string) @docstring))
+    (class_definition body: (block . (expression_statement (string) @docstring)))
+    (function_definition body: (block . (expression_statement (string) @docstring)))
+  `,
+  javascript: `
+    (comment) @jsdoc
+    (#match? @jsdoc "^/\\\\*\\\\*")
+  `,
+  typescript: `
+    (comment) @jsdoc
+    (#match? @jsdoc "^/\\\\*\\\\*")
+  `,
+  tsx: `
+    (comment) @jsdoc
+    (#match? @jsdoc "^/\\\\*\\\\*")
+  `,
+  java: `
+    (comment) @javadoc
+    (#match? @javadoc "^/\\\\*\\\\*")
+  `
+};
 var BDD_KEYWORDS = new Set([
   "given",
   "when",
@@ -1044,6 +4042,306 @@ var BDD_KEYWORDS = new Set([
   "when & then",
   "when&then"
 ]);
+var TYPE_CHECKER_PREFIXES = [
+  "type:",
+  "noqa",
+  "pyright:",
+  "ruff:",
+  "mypy:",
+  "pylint:",
+  "flake8:",
+  "pyre:",
+  "pytype:",
+  "eslint-disable",
+  "eslint-enable",
+  "eslint-ignore",
+  "prettier-ignore",
+  "ts-ignore",
+  "ts-expect-error",
+  "ts-nocheck",
+  "clippy::",
+  "allow(",
+  "deny(",
+  "warn(",
+  "forbid(",
+  "nolint",
+  "go:generate",
+  "go:build",
+  "go:embed",
+  "coverage:",
+  "c8 ignore",
+  "biome-ignore",
+  "region",
+  "endregion"
+];
+var HOOK_MESSAGE_HEADER = `COMMENT/DOCSTRING DETECTED - IMMEDIATE ACTION REQUIRED
+
+Your recent changes contain comments or docstrings, which triggered this hook.
+You need to take immediate action. You must follow the conditions below.
+(Listed in priority order - you must always act according to this priority order)
+
+CRITICAL WARNING: This hook message MUST NEVER be ignored, even if you receive it multiple times.
+You MUST provide corresponding explanation or action for EACH occurrence of this message.
+Ignoring this message or failing to respond appropriately is strictly prohibited.
+
+PRIORITY-BASED ACTION GUIDELINES:
+
+1. This is a comment/docstring that already existed before
+	-> Explain to the user that this is an existing comment/docstring and proceed (justify it)
+
+2. This is a newly written comment: but it's in given, when, then format
+	-> Tell the user it's a BDD comment and proceed (justify it)
+	-> Note: This applies to comments only, not docstrings
+
+3. This is a newly written comment/docstring: but it's a necessary comment/docstring
+	-> Tell the user why this comment/docstring is absolutely necessary and proceed (justify it)
+	-> Examples of necessary comments: complex algorithms, security-related, performance optimization, regex, mathematical formulas
+	-> Examples of necessary docstrings: public API documentation, complex module/class interfaces
+	-> IMPORTANT: Most docstrings are unnecessary if the code is self-explanatory. Only keep truly essential ones.
+
+4. This is a newly written comment/docstring: but it's an unnecessary comment/docstring
+	-> Apologize to the user and remove the comment/docstring.
+	-> Make the code itself clearer so it can be understood without comments/docstrings.
+	-> For verbose docstrings: refactor code to be self-documenting instead of adding lengthy explanations.
+
+MANDATORY REQUIREMENT: You must acknowledge this hook message and take one of the above actions.
+Review in the above priority order and take the corresponding action EVERY TIME this appears.
+
+Detected comments/docstrings:
+`;
+function getLanguageByExtension(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1) {
+    const baseName = filePath.split("/").pop()?.toLowerCase();
+    if (baseName === "dockerfile")
+      return "dockerfile";
+    return null;
+  }
+  const ext = filePath.slice(lastDot + 1).toLowerCase();
+  return EXTENSION_TO_LANGUAGE[ext] ?? null;
+}
+
+// src/hooks/comment-checker/detector.ts
+function isSupportedFile(filePath) {
+  return getLanguageByExtension(filePath) !== null;
+}
+function determineCommentType(text, nodeType) {
+  const stripped = text.trim();
+  if (nodeType === "line_comment") {
+    return "line";
+  }
+  if (nodeType === "block_comment" || nodeType === "multiline_comment") {
+    return "block";
+  }
+  if (stripped.startsWith('"""') || stripped.startsWith("'''")) {
+    return "docstring";
+  }
+  if (stripped.startsWith("//") || stripped.startsWith("#")) {
+    return "line";
+  }
+  if (stripped.startsWith("/*") || stripped.startsWith("<!--") || stripped.startsWith("--")) {
+    return "block";
+  }
+  return "line";
+}
+async function detectComments(filePath, content, includeDocstrings = true) {
+  const langName = getLanguageByExtension(filePath);
+  if (!langName) {
+    return [];
+  }
+  const queryPattern = QUERY_TEMPLATES[langName];
+  if (!queryPattern) {
+    return [];
+  }
+  try {
+    const Parser2 = (await Promise.resolve().then(() => __toESM(require_tree_sitter(), 1))).default;
+    const treeSitterWasmPath = __require.resolve("/home/runner/work/oh-my-opencode/oh-my-opencode/node_modules/web-tree-sitter/tree-sitter.wasm");
+    await Parser2.init({
+      locateFile: () => treeSitterWasmPath
+    });
+    const parser = new Parser2;
+    let wasmPath;
+    try {
+      const wasmModule = await import(`tree-sitter-wasms/out/tree-sitter-${langName}.wasm`);
+      wasmPath = wasmModule.default;
+    } catch {
+      const languageMap = {
+        golang: "go",
+        csharp: "c_sharp",
+        cpp: "cpp"
+      };
+      const mappedLang = languageMap[langName] || langName;
+      try {
+        const wasmModule = await import(`tree-sitter-wasms/out/tree-sitter-${mappedLang}.wasm`);
+        wasmPath = wasmModule.default;
+      } catch {
+        return [];
+      }
+    }
+    const language = await Parser2.Language.load(wasmPath);
+    parser.setLanguage(language);
+    const tree = parser.parse(content);
+    const comments = [];
+    const query = language.query(queryPattern);
+    const matches = query.matches(tree.rootNode);
+    for (const match of matches) {
+      for (const capture of match.captures) {
+        const node = capture.node;
+        const text = node.text;
+        const lineNumber = node.startPosition.row + 1;
+        const commentType = determineCommentType(text, node.type);
+        const isDocstring = commentType === "docstring";
+        if (isDocstring && !includeDocstrings) {
+          continue;
+        }
+        comments.push({
+          text,
+          lineNumber,
+          filePath,
+          commentType,
+          isDocstring
+        });
+      }
+    }
+    if (includeDocstrings) {
+      const docQuery = DOCSTRING_QUERIES[langName];
+      if (docQuery) {
+        try {
+          const docQueryObj = language.query(docQuery);
+          const docMatches = docQueryObj.matches(tree.rootNode);
+          for (const match of docMatches) {
+            for (const capture of match.captures) {
+              const node = capture.node;
+              const text = node.text;
+              const lineNumber = node.startPosition.row + 1;
+              const alreadyAdded = comments.some((c) => c.lineNumber === lineNumber && c.text === text);
+              if (!alreadyAdded) {
+                comments.push({
+                  text,
+                  lineNumber,
+                  filePath,
+                  commentType: "docstring",
+                  isDocstring: true
+                });
+              }
+            }
+          }
+        } catch {}
+      }
+    }
+    comments.sort((a, b) => a.lineNumber - b.lineNumber);
+    return comments;
+  } catch {
+    return [];
+  }
+}
+
+// src/hooks/comment-checker/filters/bdd.ts
+function stripCommentPrefix(text) {
+  let stripped = text.trim().toLowerCase();
+  const prefixes = ["#", "//", "--", "/*", "*/"];
+  for (const prefix of prefixes) {
+    if (stripped.startsWith(prefix)) {
+      stripped = stripped.slice(prefix.length).trim();
+    }
+  }
+  return stripped;
+}
+function filterBddComments(comment) {
+  const normalized = stripCommentPrefix(comment.text);
+  if (BDD_KEYWORDS.has(normalized)) {
+    return { shouldSkip: true, reason: `BDD keyword: ${normalized}` };
+  }
+  return { shouldSkip: false };
+}
+
+// src/hooks/comment-checker/filters/directive.ts
+function stripCommentPrefix2(text) {
+  let stripped = text.trim().toLowerCase();
+  const prefixes = ["#", "//", "/*", "--"];
+  for (const prefix of prefixes) {
+    if (stripped.startsWith(prefix)) {
+      stripped = stripped.slice(prefix.length).trim();
+    }
+  }
+  stripped = stripped.replace(/^@/, "");
+  return stripped;
+}
+function filterDirectiveComments(comment) {
+  const normalized = stripCommentPrefix2(comment.text);
+  for (const prefix of TYPE_CHECKER_PREFIXES) {
+    if (normalized.startsWith(prefix.toLowerCase())) {
+      return { shouldSkip: true, reason: `Directive: ${prefix}` };
+    }
+  }
+  return { shouldSkip: false };
+}
+
+// src/hooks/comment-checker/filters/docstring.ts
+function filterDocstringComments(comment) {
+  if (comment.isDocstring) {
+    return { shouldSkip: true, reason: "Docstring" };
+  }
+  const trimmed = comment.text.trimStart();
+  if (trimmed.startsWith("/**")) {
+    return { shouldSkip: true, reason: "JSDoc/PHPDoc" };
+  }
+  return { shouldSkip: false };
+}
+
+// src/hooks/comment-checker/filters/shebang.ts
+function filterShebangComments(comment) {
+  const trimmed = comment.text.trimStart();
+  if (trimmed.startsWith("#!")) {
+    return { shouldSkip: true, reason: "Shebang" };
+  }
+  return { shouldSkip: false };
+}
+
+// src/hooks/comment-checker/filters/index.ts
+var ALL_FILTERS = [
+  filterShebangComments,
+  filterBddComments,
+  filterDirectiveComments,
+  filterDocstringComments
+];
+function applyFilters(comments) {
+  return comments.filter((comment) => {
+    for (const filter of ALL_FILTERS) {
+      const result = filter(comment);
+      if (result.shouldSkip) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+// src/hooks/comment-checker/output/xml-builder.ts
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildCommentsXml(fileCommentsList) {
+  const lines = [];
+  for (const fc of fileCommentsList) {
+    lines.push(`<comments file="${escapeXml(fc.filePath)}">`);
+    for (const comment of fc.comments) {
+      lines.push(`	<comment line-number="${comment.lineNumber}">${escapeXml(comment.text)}</comment>`);
+    }
+    lines.push(`</comments>`);
+  }
+  return lines.join(`
+`);
+}
+// src/hooks/comment-checker/output/formatter.ts
+function formatHookMessage(fileCommentsList) {
+  if (fileCommentsList.length === 0) {
+    return "";
+  }
+  const xml = buildCommentsXml(fileCommentsList);
+  return `${HOOK_MESSAGE_HEADER}${xml}
+`;
+}
 // src/hooks/comment-checker/index.ts
 var pendingCalls = new Map;
 var PENDING_CALL_TTL = 60000;
@@ -1056,6 +4354,65 @@ function cleanupOldPendingCalls() {
   }
 }
 setInterval(cleanupOldPendingCalls, 1e4);
+function createCommentCheckerHooks() {
+  return {
+    "tool.execute.before": async (input, output) => {
+      const toolLower = input.tool.toLowerCase();
+      if (toolLower !== "write" && toolLower !== "edit" && toolLower !== "multiedit") {
+        return;
+      }
+      const filePath = output.args.filePath ?? output.args.file_path;
+      const content = output.args.content;
+      if (!filePath) {
+        return;
+      }
+      if (!isSupportedFile(filePath)) {
+        return;
+      }
+      pendingCalls.set(input.callID, {
+        filePath,
+        content,
+        tool: toolLower,
+        sessionID: input.sessionID,
+        timestamp: Date.now()
+      });
+    },
+    "tool.execute.after": async (input, output) => {
+      const pendingCall = pendingCalls.get(input.callID);
+      if (!pendingCall) {
+        return;
+      }
+      pendingCalls.delete(input.callID);
+      if (output.output.toLowerCase().includes("error")) {
+        return;
+      }
+      try {
+        let content;
+        if (pendingCall.content) {
+          content = pendingCall.content;
+        } else {
+          const file = Bun.file(pendingCall.filePath);
+          content = await file.text();
+        }
+        const rawComments = await detectComments(pendingCall.filePath, content);
+        const filteredComments = applyFilters(rawComments);
+        if (filteredComments.length === 0) {
+          return;
+        }
+        const fileComments = [
+          {
+            filePath: pendingCall.filePath,
+            comments: filteredComments
+          }
+        ];
+        const message = formatHookMessage(fileComments);
+        output.output += `
+
+${message}`;
+      } catch {}
+    }
+  };
+}
 // src/features/terminal/title.ts
 var STATUS_ICONS = {
   ready: "",
@@ -1074,11 +4431,11 @@ function truncate(str, maxLen) {
 function formatTerminalTitle(ctx) {
   const title = ctx.sessionTitle || DEFAULT_TITLE;
   const truncatedTitle = truncate(title, MAX_TITLE_LENGTH);
-  const parts = ["[OpenCode]", truncatedTitle];
+  const parts2 = ["[OpenCode]", truncatedTitle];
   if (ctx.status) {
-    parts.push(STATUS_ICONS[ctx.status]);
+    parts2.push(STATUS_ICONS[ctx.status]);
   }
-  return parts.join(" ");
+  return parts2.join(" ");
 }
 function isTmuxEnvironment() {
   return !!process.env.TMUX || process.env.TERM_PROGRAM === "tmux";
@@ -1475,7 +4832,7 @@ class LSPServerManager {
       this.clients.delete(key);
     }
     const client = new LSPClient(root, server);
-    const initPromise = (async () => {
+    const initPromise2 = (async () => {
       await client.start();
       await client.initialize();
     })();
@@ -1483,10 +4840,10 @@ class LSPServerManager {
       client,
       lastUsedAt: Date.now(),
       refCount: 1,
-      initPromise,
+      initPromise: initPromise2,
       isInitializing: true
     });
-    await initPromise;
+    await initPromise2;
     const m = this.clients.get(key);
     if (m) {
       m.initPromise = undefined;
@@ -1499,7 +4856,7 @@ class LSPServerManager {
     if (this.clients.has(key))
       return;
     const client = new LSPClient(root, server);
-    const initPromise = (async () => {
+    const initPromise2 = (async () => {
       await client.start();
       await client.initialize();
     })();
@@ -1507,10 +4864,10 @@ class LSPServerManager {
       client,
       lastUsedAt: Date.now(),
       refCount: 0,
-      initPromise,
+      initPromise: initPromise2,
       isInitializing: true
     });
-    initPromise.then(() => {
+    initPromise2.then(() => {
       const m = this.clients.get(key);
       if (m) {
         m.initPromise = undefined;
@@ -1601,9 +4958,9 @@ stderr: ${stderr}` : ""));
           this.buffer = newBuf;
           this.processBuffer();
         }
-      } catch (err) {
+      } catch (err2) {
         this.processExited = true;
-        this.rejectAllPending(`LSP stdout read error: ${err}`);
+        this.rejectAllPending(`LSP stdout read error: ${err2}`);
       }
     };
     read();
@@ -1637,12 +4994,12 @@ stderr: ${stderr}` : ""));
   }
   findSequence(haystack, needle) {
     outer:
-      for (let i = 0;i <= haystack.length - needle.length; i++) {
+      for (let i2 = 0;i2 <= haystack.length - needle.length; i2++) {
         for (let j = 0;j < needle.length; j++) {
-          if (haystack[i + j] !== needle[j])
+          if (haystack[i2 + j] !== needle[j])
             continue outer;
         }
-        return i;
+        return i2;
       }
     return -1;
   }
@@ -1670,11 +5027,11 @@ stderr: ${stderr}` : ""));
       if (!match)
         break;
       const len = parseInt(match[1], 10);
-      const start = headerEnd + sepLen;
-      const end = start + len;
+      const start2 = headerEnd + sepLen;
+      const end = start2 + len;
       if (this.buffer.length < end)
         break;
-      const content = decoder.decode(this.buffer.slice(start, end));
+      const content = decoder.decode(this.buffer.slice(start2, end));
       this.buffer = this.buffer.slice(end);
       try {
         const msg = JSON.parse(content);
@@ -2062,12 +5419,12 @@ function formatCodeActions(actions) {
   if (!actions || actions.length === 0)
     return "No code actions available";
   const lines = [];
-  for (let i = 0;i < actions.length; i++) {
-    const action = actions[i];
+  for (let i2 = 0;i2 < actions.length; i2++) {
+    const action = actions[i2];
     if ("command" in action && typeof action.command === "string" && !("kind" in action)) {
-      lines.push(`${i + 1}. [command] ${action.title}`);
+      lines.push(`${i2 + 1}. [command] ${action.title}`);
     } else {
-      lines.push(`${i + 1}. ${formatCodeAction(action)}`);
+      lines.push(`${i2 + 1}. ${formatCodeAction(action)}`);
     }
   }
   return lines.join(`
@@ -2103,8 +5460,8 @@ function applyTextEditsToFile(filePath, edits) {
     writeFileSync(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
-  } catch (err) {
-    return { success: false, editCount: 0, error: err instanceof Error ? err.message : String(err) };
+  } catch (err2) {
+    return { success: false, editCount: 0, error: err2 instanceof Error ? err2.message : String(err2) };
   }
 }
 function applyWorkspaceEdit(edit) {
@@ -2133,9 +5490,9 @@ function applyWorkspaceEdit(edit) {
             const filePath = change.uri.replace("file://", "");
             writeFileSync(filePath, "", "utf-8");
             result.filesModified.push(filePath);
-          } catch (err) {
+          } catch (err2) {
             result.success = false;
-            result.errors.push(`Create ${change.uri}: ${err}`);
+            result.errors.push(`Create ${change.uri}: ${err2}`);
           }
         } else if (change.kind === "rename") {
           try {
@@ -2145,18 +5502,18 @@ function applyWorkspaceEdit(edit) {
             writeFileSync(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
-          } catch (err) {
+          } catch (err2) {
             result.success = false;
-            result.errors.push(`Rename ${change.oldUri}: ${err}`);
+            result.errors.push(`Rename ${change.oldUri}: ${err2}`);
           }
         } else if (change.kind === "delete") {
           try {
             const filePath = change.uri.replace("file://", "");
             __require("fs").unlinkSync(filePath);
             result.filesModified.push(filePath);
-          } catch (err) {
+          } catch (err2) {
             result.success = false;
-            result.errors.push(`Delete ${change.uri}: ${err}`);
+            result.errors.push(`Delete ${change.uri}: ${err2}`);
           }
         }
       } else {
@@ -2183,8 +5540,8 @@ function formatApplyResult(result) {
     }
   } else {
     lines.push("Failed to apply some changes:");
-    for (const err of result.errors) {
-      lines.push(`  Error: ${err}`);
+    for (const err2 of result.errors) {
+      lines.push(`  Error: ${err2}`);
     }
     if (result.filesModified.length > 0) {
       lines.push(`Successfully modified: ${result.filesModified.join(", ")}`);
@@ -2691,15 +6048,15 @@ __export(exports_core2, {
 var NEVER = Object.freeze({
   status: "aborted"
 });
-function $constructor(name, initializer, params) {
-  function init(inst, def) {
+function $constructor(name2, initializer, params) {
+  function init2(inst, def) {
     var _a;
     Object.defineProperty(inst, "_zod", {
       value: inst._zod ?? {},
       enumerable: false
     });
     (_a = inst._zod).traits ?? (_a.traits = new Set);
-    inst._zod.traits.add(name);
+    inst._zod.traits.add(name2);
     initializer(inst, def);
     for (const k in _.prototype) {
       if (!(k in inst))
@@ -2712,26 +6069,26 @@ function $constructor(name, initializer, params) {
 
   class Definition extends Parent {
   }
-  Object.defineProperty(Definition, "name", { value: name });
+  Object.defineProperty(Definition, "name", { value: name2 });
   function _(def) {
     var _a;
     const inst = params?.Parent ? new Definition : this;
-    init(inst, def);
+    init2(inst, def);
     (_a = inst._zod).deferred ?? (_a.deferred = []);
     for (const fn of inst._zod.deferred) {
       fn();
     }
     return inst;
   }
-  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, "init", { value: init2 });
   Object.defineProperty(_, Symbol.hasInstance, {
     value: (inst) => {
       if (params?.Parent && inst instanceof params.Parent)
         return true;
-      return inst?._zod?.traits?.has(name);
+      return inst?._zod?.traits?.has(name2);
     }
   });
-  Object.defineProperty(_, "name", { value: name });
+  Object.defineProperty(_, "name", { value: name2 });
   return _;
 }
 var $brand = Symbol("zod_brand");
@@ -2743,8 +6100,8 @@ class $ZodAsyncError extends Error {
 }
 
 class $ZodEncodeError extends Error {
-  constructor(name) {
-    super(`Encountered unidirectional transform during encode: ${name}`);
+  constructor(name2) {
+    super(`Encountered unidirectional transform during encode: ${name2}`);
     this.name = "ZodEncodeError";
   }
 }
@@ -2859,9 +6216,9 @@ function nullish(input) {
   return input === null || input === undefined;
 }
 function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
+  const start2 = source.startsWith("^") ? 1 : 0;
   const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
+  return source.slice(start2, end);
 }
 function floatSafeRemainder(val, step) {
   const valDecCount = (val.toString().split(".")[1] || "").length;
@@ -2932,8 +6289,8 @@ function promiseAllObject(promisesObj) {
   const promises = keys.map((key) => promisesObj[key]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
-    for (let i = 0;i < keys.length; i++) {
-      resolvedObj[keys[i]] = results[i];
+    for (let i2 = 0;i2 < keys.length; i2++) {
+      resolvedObj[keys[i2]] = results[i2];
     }
     return resolvedObj;
   });
@@ -2941,7 +6298,7 @@ function promiseAllObject(promisesObj) {
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
   let str = "";
-  for (let i = 0;i < length; i++) {
+  for (let i2 = 0;i2 < length; i2++) {
     str += chars[Math.floor(Math.random() * chars.length)];
   }
   return str;
@@ -3277,8 +6634,8 @@ function required(Class, schema, mask) {
 function aborted(x, startIndex = 0) {
   if (x.aborted === true)
     return true;
-  for (let i = startIndex;i < x.issues.length; i++) {
-    if (x.issues[i]?.continue !== true) {
+  for (let i2 = startIndex;i2 < x.issues.length; i2++) {
+    if (x.issues[i2]?.continue !== true) {
       return true;
     }
   }
@@ -3324,8 +6681,8 @@ function getLengthableOrigin(input) {
     return "string";
   return "unknown";
 }
-function issue(...args) {
-  const [iss, input, inst] = args;
+function issue(...args2) {
+  const [iss, input, inst] = args2;
   if (typeof iss === "string") {
     return {
       message: iss,
@@ -3344,15 +6701,15 @@ function cleanEnum(obj) {
 function base64ToUint8Array(base64) {
   const binaryString = atob(base64);
   const bytes = new Uint8Array(binaryString.length);
-  for (let i = 0;i < binaryString.length; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
+  for (let i2 = 0;i2 < binaryString.length; i2++) {
+    bytes[i2] = binaryString.charCodeAt(i2);
   }
   return bytes;
 }
 function uint8ArrayToBase64(bytes) {
   let binaryString = "";
-  for (let i = 0;i < bytes.length; i++) {
-    binaryString += String.fromCharCode(bytes[i]);
+  for (let i2 = 0;i2 < bytes.length; i2++) {
+    binaryString += String.fromCharCode(bytes[i2]);
   }
   return btoa(binaryString);
 }
@@ -3370,8 +6727,8 @@ function hexToUint8Array(hex) {
     throw new Error("Invalid hex string length");
   }
   const bytes = new Uint8Array(cleanHex.length / 2);
-  for (let i = 0;i < cleanHex.length; i += 2) {
-    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
+  for (let i2 = 0;i2 < cleanHex.length; i2 += 2) {
+    bytes[i2 / 2] = Number.parseInt(cleanHex.slice(i2, i2 + 2), 16);
   }
   return bytes;
 }
@@ -3432,10 +6789,10 @@ function formatError(error, _mapper) {
         fieldErrors._errors.push(mapper(issue2));
       } else {
         let curr = fieldErrors;
-        let i = 0;
-        while (i < issue2.path.length) {
-          const el = issue2.path[i];
-          const terminal = i === issue2.path.length - 1;
+        let i2 = 0;
+        while (i2 < issue2.path.length) {
+          const el = issue2.path[i2];
+          const terminal = i2 === issue2.path.length - 1;
           if (!terminal) {
             curr[el] = curr[el] || { _errors: [] };
           } else {
@@ -3443,7 +6800,7 @@ function formatError(error, _mapper) {
             curr[el]._errors.push(mapper(issue2));
           }
           curr = curr[el];
-          i++;
+          i2++;
         }
       }
     }
@@ -3472,10 +6829,10 @@ function treeifyError(error, _mapper) {
           continue;
         }
         let curr = result;
-        let i = 0;
-        while (i < fullpath.length) {
-          const el = fullpath[i];
-          const terminal = i === fullpath.length - 1;
+        let i2 = 0;
+        while (i2 < fullpath.length) {
+          const el = fullpath[i2];
+          const terminal = i2 === fullpath.length - 1;
           if (typeof el === "string") {
             curr.properties ?? (curr.properties = {});
             (_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
@@ -3488,7 +6845,7 @@ function treeifyError(error, _mapper) {
           if (terminal) {
             curr.errors.push(mapper(issue2));
           }
-          i++;
+          i2++;
         }
       }
     }
@@ -3712,20 +7069,20 @@ var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
 var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
 var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
-function timeSource(args) {
+function timeSource(args2) {
   const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
-  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+  const regex = typeof args2.precision === "number" ? args2.precision === -1 ? `${hhmm}` : args2.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args2.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
   return regex;
 }
-function time(args) {
-  return new RegExp(`^${timeSource(args)}$`);
+function time(args2) {
+  return new RegExp(`^${timeSource(args2)}$`);
 }
-function datetime(args) {
-  const time2 = timeSource({ precision: args.precision });
+function datetime(args2) {
+  const time2 = timeSource({ precision: args2.precision });
   const opts = ["Z"];
-  if (args.local)
+  if (args2.local)
     opts.push("");
-  if (args.offset)
+  if (args2.offset)
     opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
   const timeRegex = `${time2}(?:${opts.join("|")})`;
   return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
@@ -4308,11 +7665,11 @@ var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (ins
 
 // node_modules/zod/v4/core/doc.js
 class Doc {
-  constructor(args = []) {
+  constructor(args2 = []) {
     this.content = [];
     this.indent = 0;
     if (this)
-      this.args = args;
+      this.args = args2;
   }
   indented(fn) {
     this.indent += 1;
@@ -4336,10 +7693,10 @@ class Doc {
   }
   compile() {
     const F = Function;
-    const args = this?.args;
+    const args2 = this?.args;
     const content = this?.content ?? [``];
     const lines = [...content.map((x) => `  ${x}`)];
-    return new F(...args, lines.join(`
+    return new F(...args2, lines.join(`
 `));
   }
 }
@@ -4644,11 +8001,11 @@ var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
   def.pattern ?? (def.pattern = cidrv6);
   $ZodStringFormat.init(inst, def);
   inst._zod.check = (payload) => {
-    const parts = payload.value.split("/");
+    const parts2 = payload.value.split("/");
     try {
-      if (parts.length !== 2)
+      if (parts2.length !== 2)
         throw new Error;
-      const [address, prefix] = parts;
+      const [address, prefix] = parts2;
       if (!prefix)
         throw new Error;
       const prefixNum = Number(prefix);
@@ -4975,16 +8332,16 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     }
     payload.value = Array(input.length);
     const proms = [];
-    for (let i = 0;i < input.length; i++) {
-      const item = input[i];
+    for (let i2 = 0;i2 < input.length; i2++) {
+      const item = input[i2];
       const result = def.element._zod.run({
         value: item,
         issues: []
       }, ctx);
       if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+        proms.push(result.then((result2) => handleArrayResult(result2, payload, i2)));
       } else {
-        handleArrayResult(result, payload, i);
+        handleArrayResult(result, payload, i2);
       }
     }
     if (proms.length) {
@@ -5415,35 +8772,35 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
         return payload;
       }
     }
-    let i = -1;
+    let i2 = -1;
     for (const item of items) {
-      i++;
-      if (i >= input.length) {
-        if (i >= optStart)
+      i2++;
+      if (i2 >= input.length) {
+        if (i2 >= optStart)
           continue;
       }
       const result = item._zod.run({
-        value: input[i],
+        value: input[i2],
         issues: []
       }, ctx);
       if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+        proms.push(result.then((result2) => handleTupleResult(result2, payload, i2)));
       } else {
-        handleTupleResult(result, payload, i);
+        handleTupleResult(result, payload, i2);
       }
     }
     if (def.rest) {
       const rest = input.slice(items.length);
       for (const el of rest) {
-        i++;
+        i2++;
         const result = def.rest._zod.run({
           value: el,
           issues: []
         }, ctx);
         if (result instanceof Promise) {
-          proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+          proms.push(result.then((result2) => handleTupleResult(result2, payload, i2)));
         } else {
-          handleTupleResult(result, payload, i);
+          handleTupleResult(result, payload, i2);
         }
       }
     }
@@ -6015,9 +9372,9 @@ var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (i
       const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
       if (!source)
         throw new Error(`Invalid template literal part: ${part._zod.traits}`);
-      const start = source.startsWith("^") ? 1 : 0;
+      const start2 = source.startsWith("^") ? 1 : 0;
       const end = source.endsWith("$") ? source.length - 1 : source.length;
-      regexParts.push(source.slice(start, end));
+      regexParts.push(source.slice(start2, end));
     } else if (part === null || primitiveTypes.has(typeof part)) {
       regexParts.push(escapeRegex(`${part}`));
     } else {
@@ -6053,26 +9410,26 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
   $ZodType.init(inst, def);
   inst._def = def;
   inst._zod.def = def;
-  inst.implement = (func) => {
-    if (typeof func !== "function") {
+  inst.implement = (func2) => {
+    if (typeof func2 !== "function") {
       throw new Error("implement() must be called with a function");
     }
-    return function(...args) {
-      const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
-      const result = Reflect.apply(func, this, parsedArgs);
+    return function(...args2) {
+      const parsedArgs = inst._def.input ? parse(inst._def.input, args2) : args2;
+      const result = Reflect.apply(func2, this, parsedArgs);
       if (inst._def.output) {
         return parse(inst._def.output, result);
       }
       return result;
     };
   };
-  inst.implementAsync = (func) => {
-    if (typeof func !== "function") {
+  inst.implementAsync = (func2) => {
+    if (typeof func2 !== "function") {
       throw new Error("implementAsync() must be called with a function");
     }
-    return async function(...args) {
-      const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
-      const result = await Reflect.apply(func, this, parsedArgs);
+    return async function(...args2) {
+      const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args2) : args2;
+      const result = await Reflect.apply(func2, this, parsedArgs);
       if (inst._def.output) {
         return await parseAsync(inst._def.output, result);
       }
@@ -6097,22 +9454,22 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
     }
     return payload;
   };
-  inst.input = (...args) => {
+  inst.input = (...args2) => {
     const F = inst.constructor;
-    if (Array.isArray(args[0])) {
+    if (Array.isArray(args2[0])) {
       return new F({
         type: "function",
         input: new $ZodTuple({
           type: "tuple",
-          items: args[0],
-          rest: args[1]
+          items: args2[0],
+          rest: args2[1]
         }),
         output: inst._def.output
       });
     }
     return new F({
       type: "function",
-      input: args[0],
+      input: args2[0],
       output: inst._def.output
     });
   };
@@ -12440,11 +15797,11 @@ function _catch(Class2, innerType, catchValue) {
     catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
   });
 }
-function _pipe(Class2, in_, out) {
+function _pipe(Class2, in_, out2) {
   return new Class2({
     type: "pipe",
     in: in_,
-    out
+    out: out2
   });
 }
 function _readonly(Class2, innerType) {
@@ -12453,10 +15810,10 @@ function _readonly(Class2, innerType) {
     innerType
   });
 }
-function _templateLiteral(Class2, parts, params) {
+function _templateLiteral(Class2, parts2, params) {
   return new Class2({
     type: "template_literal",
-    parts,
+    parts: parts2,
     ...normalizeParams(params)
   });
 }
@@ -12813,9 +16170,9 @@ class JSONSchemaGenerator {
           }
           case "union": {
             const json = _json;
-            const options = def.options.map((x, i) => this.process(x, {
+            const options = def.options.map((x, i2) => this.process(x, {
               ...params,
-              path: [...params.path, "anyOf", i]
+              path: [...params.path, "anyOf", i2]
             }));
             json.anyOf = options;
             break;
@@ -12843,9 +16200,9 @@ class JSONSchemaGenerator {
             json.type = "array";
             const prefixPath = this.target === "draft-2020-12" ? "prefixItems" : "items";
             const restPath = this.target === "draft-2020-12" ? "items" : this.target === "openapi-3.0" ? "items" : "additionalItems";
-            const prefixItems = def.items.map((x, i) => this.process(x, {
+            const prefixItems = def.items.map((x, i2) => this.process(x, {
               ...params,
-              path: [...params.path, prefixPath, i]
+              path: [...params.path, prefixPath, i2]
             }));
             const rest = def.rest ? this.process(def.rest, {
               ...params,
@@ -13543,12 +16900,12 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     },
     configurable: true
   });
-  inst.meta = (...args) => {
-    if (args.length === 0) {
+  inst.meta = (...args2) => {
+    if (args2.length === 0) {
       return globalRegistry.get(inst);
     }
     const cl = inst.clone();
-    globalRegistry.add(cl, args[0]);
+    globalRegistry.add(cl, args2[0]);
     return cl;
   };
   inst.isOptional = () => inst.safeParse(undefined).success;
@@ -13562,18 +16919,18 @@ var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
   inst.format = bag.format ?? null;
   inst.minLength = bag.minimum ?? null;
   inst.maxLength = bag.maximum ?? null;
-  inst.regex = (...args) => inst.check(_regex(...args));
-  inst.includes = (...args) => inst.check(_includes(...args));
-  inst.startsWith = (...args) => inst.check(_startsWith(...args));
-  inst.endsWith = (...args) => inst.check(_endsWith(...args));
-  inst.min = (...args) => inst.check(_minLength(...args));
-  inst.max = (...args) => inst.check(_maxLength(...args));
-  inst.length = (...args) => inst.check(_length(...args));
-  inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
+  inst.regex = (...args2) => inst.check(_regex(...args2));
+  inst.includes = (...args2) => inst.check(_includes(...args2));
+  inst.startsWith = (...args2) => inst.check(_startsWith(...args2));
+  inst.endsWith = (...args2) => inst.check(_endsWith(...args2));
+  inst.min = (...args2) => inst.check(_minLength(...args2));
+  inst.max = (...args2) => inst.check(_maxLength(...args2));
+  inst.length = (...args2) => inst.check(_length(...args2));
+  inst.nonempty = (...args2) => inst.check(_minLength(1, ...args2));
   inst.lowercase = (params) => inst.check(_lowercase(params));
   inst.uppercase = (params) => inst.check(_uppercase(params));
   inst.trim = () => inst.check(_trim());
-  inst.normalize = (...args) => inst.check(_normalize(...args));
+  inst.normalize = (...args2) => inst.check(_normalize(...args2));
   inst.toLowerCase = () => inst.check(_toLowerCase());
   inst.toUpperCase = () => inst.check(_toUpperCase());
 });
@@ -13970,8 +17327,8 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   inst.merge = (other) => exports_util.merge(inst, other);
   inst.pick = (mask) => exports_util.pick(inst, mask);
   inst.omit = (mask) => exports_util.omit(inst, mask);
-  inst.partial = (...args) => exports_util.partial(ZodOptional, inst, args[0]);
-  inst.required = (...args) => exports_util.required(ZodNonOptional, inst, args[0]);
+  inst.partial = (...args2) => exports_util.partial(ZodOptional, inst, args2[0]);
+  inst.required = (...args2) => exports_util.required(ZodNonOptional, inst, args2[0]);
 });
 function object(shape, params) {
   const def = {
@@ -14101,10 +17458,10 @@ function map(keyType, valueType, params) {
 var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst.min = (...args) => inst.check(_minSize(...args));
+  inst.min = (...args2) => inst.check(_minSize(...args2));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
-  inst.max = (...args) => inst.check(_maxSize(...args));
-  inst.size = (...args) => inst.check(_size(...args));
+  inst.max = (...args2) => inst.check(_maxSize(...args2));
+  inst.size = (...args2) => inst.check(_size(...args2));
 });
 function set(valueType, params) {
   return new ZodSet({
@@ -14335,22 +17692,22 @@ var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   inst.in = def.in;
   inst.out = def.out;
 });
-function pipe(in_, out) {
+function pipe(in_, out2) {
   return new ZodPipe({
     type: "pipe",
     in: in_,
-    out
+    out: out2
   });
 }
 var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
   ZodPipe.init(inst, def);
   $ZodCodec.init(inst, def);
 });
-function codec(in_, out, params) {
+function codec(in_, out2, params) {
   return new ZodCodec({
     type: "pipe",
     in: in_,
-    out,
+    out: out2,
     transform: params.decode,
     reverseTransform: params.encode
   });
@@ -14370,10 +17727,10 @@ var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (ins
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
 });
-function templateLiteral(parts, params) {
+function templateLiteral(parts2, params) {
   return new ZodTemplateLiteral({
     type: "template_literal",
-    parts,
+    parts: parts2,
     ...exports_util.normalizeParams(params)
   });
 }
@@ -14443,11 +17800,11 @@ function _instanceof(cls, params = {
   inst._zod.bag.Class = cls;
   return inst;
 }
-var stringbool = (...args) => _stringbool({
+var stringbool = (...args2) => _stringbool({
   Codec: ZodCodec,
   Boolean: ZodBoolean,
   String: ZodString
-}, ...args);
+}, ...args2);
 function json(params) {
   const jsonSchema = lazy(() => {
     return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
@@ -14522,10 +17879,10 @@ var lsp_hover = tool({
     line: tool.schema.number().min(1).describe("Line number (1-based)"),
     character: tool.schema.number().min(0).describe("Character position (0-based)")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.hover(args.filePath, args.line, args.character);
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.hover(args2.filePath, args2.line, args2.character);
       });
       const output = formatHoverResult(result);
       return output;
@@ -14542,10 +17899,10 @@ var lsp_goto_definition = tool({
     line: tool.schema.number().min(1).describe("Line number (1-based)"),
     character: tool.schema.number().min(0).describe("Character position (0-based)")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.definition(args.filePath, args.line, args.character);
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.definition(args2.filePath, args2.line, args2.character);
       });
       if (!result) {
         const output2 = "No definition found";
@@ -14573,10 +17930,10 @@ var lsp_find_references = tool({
     character: tool.schema.number().min(0).describe("Character position (0-based)"),
     includeDeclaration: tool.schema.boolean().optional().describe("Include the declaration itself")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.references(args.filePath, args.line, args.character, args.includeDeclaration ?? true);
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.references(args2.filePath, args2.line, args2.character, args2.includeDeclaration ?? true);
       });
       if (!result || result.length === 0) {
         const output2 = "No references found";
@@ -14596,10 +17953,10 @@ var lsp_document_symbols = tool({
   args: {
     filePath: tool.schema.string().describe("The absolute path to the file")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.documentSymbols(args.filePath);
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.documentSymbols(args2.filePath);
       });
       if (!result || result.length === 0) {
         const output2 = "No symbols found";
@@ -14627,16 +17984,16 @@ var lsp_workspace_symbols = tool({
     query: tool.schema.string().describe("The symbol name to search for (supports fuzzy matching)"),
     limit: tool.schema.number().optional().describe("Maximum number of results to return")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.workspaceSymbols(args.query);
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.workspaceSymbols(args2.query);
       });
       if (!result || result.length === 0) {
         const output2 = "No symbols found";
         return output2;
       }
-      const limited = args.limit ? result.slice(0, args.limit) : result;
+      const limited = args2.limit ? result.slice(0, args2.limit) : result;
       const output = limited.map(formatSymbolInfo).join(`
 `);
       return output;
@@ -14652,10 +18009,10 @@ var lsp_diagnostics = tool({
     filePath: tool.schema.string().describe("The absolute path to the file"),
     severity: tool.schema.enum(["error", "warning", "information", "hint", "all"]).optional().describe("Filter by severity level")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.diagnostics(args.filePath);
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.diagnostics(args2.filePath);
       });
       let diagnostics = [];
       if (result) {
@@ -14665,7 +18022,7 @@ var lsp_diagnostics = tool({
           diagnostics = result.items;
         }
       }
-      diagnostics = filterDiagnosticsBySeverity(diagnostics, args.severity);
+      diagnostics = filterDiagnosticsBySeverity(diagnostics, args2.severity);
       if (diagnostics.length === 0) {
         const output2 = "No diagnostics found";
         return output2;
@@ -14708,10 +18065,10 @@ var lsp_prepare_rename = tool({
     line: tool.schema.number().min(1).describe("Line number (1-based)"),
     character: tool.schema.number().min(0).describe("Character position (0-based)")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.prepareRename(args.filePath, args.line, args.character);
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.prepareRename(args2.filePath, args2.line, args2.character);
       });
       const output = formatPrepareRenameResult(result);
       return output;
@@ -14729,10 +18086,10 @@ var lsp_rename = tool({
     character: tool.schema.number().min(0).describe("Character position (0-based)"),
     newName: tool.schema.string().describe("The new name for the symbol")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const edit = await withLspClient(args.filePath, async (client) => {
-        return await client.rename(args.filePath, args.line, args.character, args.newName);
+      const edit = await withLspClient(args2.filePath, async (client) => {
+        return await client.rename(args2.filePath, args2.line, args2.character, args2.newName);
       });
       const result = applyWorkspaceEdit(edit);
       const output = formatApplyResult(result);
@@ -14762,11 +18119,11 @@ var lsp_code_actions = tool({
       "source.fixAll"
     ]).optional().describe("Filter by code action kind")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const only = args.kind ? [args.kind] : undefined;
-      const result = await withLspClient(args.filePath, async (client) => {
-        return await client.codeAction(args.filePath, args.startLine, args.startCharacter, args.endLine, args.endCharacter, only);
+      const only = args2.kind ? [args2.kind] : undefined;
+      const result = await withLspClient(args2.filePath, async (client) => {
+        return await client.codeAction(args2.filePath, args2.startLine, args2.startCharacter, args2.endLine, args2.endCharacter, only);
       });
       const output = formatCodeActions(result);
       return output;
@@ -14782,10 +18139,10 @@ var lsp_code_action_resolve = tool({
     filePath: tool.schema.string().describe("The absolute path to a file in the workspace (used to find the LSP server)"),
     codeAction: tool.schema.string().describe("The code action JSON object as returned by lsp_code_actions (stringified)")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const codeAction = JSON.parse(args.codeAction);
-      const resolved = await withLspClient(args.filePath, async (client) => {
+      const codeAction = JSON.parse(args2.codeAction);
+      const resolved = await withLspClient(args2.filePath, async (client) => {
         return await client.codeActionResolve(codeAction);
       });
       if (!resolved) {
@@ -14917,24 +18274,24 @@ var LANG_EXTENSIONS = {
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn2 } = globalThis.Bun;
 async function runSg(options) {
-  const args = ["run", "-p", options.pattern, "--lang", options.lang, "--json=compact"];
+  const args2 = ["run", "-p", options.pattern, "--lang", options.lang, "--json=compact"];
   if (options.rewrite) {
-    args.push("-r", options.rewrite);
+    args2.push("-r", options.rewrite);
     if (options.updateAll) {
-      args.push("--update-all");
+      args2.push("--update-all");
     }
   }
   if (options.context && options.context > 0) {
-    args.push("-C", String(options.context));
+    args2.push("-C", String(options.context));
   }
   if (options.globs) {
     for (const glob of options.globs) {
-      args.push("--globs", glob);
+      args2.push("--globs", glob);
     }
   }
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
-  args.push(...paths);
-  const proc = spawn2([SG_CLI_PATH, ...args], {
+  args2.push(...paths);
+  const proc = spawn2([SG_CLI_PATH, ...args2], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -14989,11 +18346,11 @@ function extractMetaVariablesFromPattern(pattern) {
 function extractMetaVariables(node, pattern) {
   const varNames = extractMetaVariablesFromPattern(pattern);
   const result = [];
-  for (const name of varNames) {
-    const match = node.getMatch(name);
+  for (const name2 of varNames) {
+    const match = node.getMatch(name2);
     if (match) {
       result.push({
-        name,
+        name: name2,
         text: match.text(),
         kind: String(match.kind())
       });
@@ -15117,14 +18474,14 @@ var ast_grep_search = tool({
     globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
     context: tool.schema.number().optional().describe("Context lines around match")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
       const matches = await runSg({
-        pattern: args.pattern,
-        lang: args.lang,
-        paths: args.paths,
-        globs: args.globs,
-        context: args.context
+        pattern: args2.pattern,
+        lang: args2.lang,
+        paths: args2.paths,
+        globs: args2.globs,
+        context: args2.context
       });
       const output = formatSearchResult(matches);
       showOutputToUser(context, output);
@@ -15146,17 +18503,17 @@ var ast_grep_replace = tool({
     globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs"),
     dryRun: tool.schema.boolean().optional().describe("Preview changes without applying (default: true)")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
       const matches = await runSg({
-        pattern: args.pattern,
-        rewrite: args.rewrite,
-        lang: args.lang,
-        paths: args.paths,
-        globs: args.globs,
-        updateAll: args.dryRun === false
+        pattern: args2.pattern,
+        rewrite: args2.rewrite,
+        lang: args2.lang,
+        paths: args2.paths,
+        globs: args2.globs,
+        updateAll: args2.dryRun === false
       });
-      const output = formatReplaceResult(matches, args.dryRun !== false);
+      const output = formatReplaceResult(matches, args2.dryRun !== false);
       showOutputToUser(context, output);
       return output;
     } catch (e) {
@@ -15191,17 +18548,17 @@ var ast_grep_analyze = tool({
     pattern: tool.schema.string().optional().describe("Pattern to find (omit for root structure)"),
     extractMetaVars: tool.schema.boolean().optional().describe("Extract meta-variable bindings (default: true)")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      if (!args.pattern) {
-        const info = getRootInfo(args.code, args.lang);
-        const output2 = `Root kind: ${info.kind}
-Children: ${info.childCount}`;
+      if (!args2.pattern) {
+        const info2 = getRootInfo(args2.code, args2.lang);
+        const output2 = `Root kind: ${info2.kind}
+Children: ${info2.childCount}`;
         showOutputToUser(context, output2);
         return output2;
       }
-      const results = analyzeCode(args.code, args.lang, args.pattern, args.extractMetaVars !== false);
-      const output = formatAnalyzeResult(results, args.extractMetaVars !== false);
+      const results = analyzeCode(args2.code, args2.lang, args2.pattern, args2.extractMetaVars !== false);
+      const output = formatAnalyzeResult(results, args2.extractMetaVars !== false);
       showOutputToUser(context, output);
       return output;
     } catch (e) {
@@ -15219,10 +18576,10 @@ var ast_grep_transform = tool({
     pattern: tool.schema.string().describe("Pattern to match"),
     rewrite: tool.schema.string().describe("Replacement (can use $VAR from pattern)")
   },
-  execute: async (args, context) => {
+  execute: async (args2, context) => {
     try {
-      const { transformed, editCount } = transformCode(args.code, args.lang, args.pattern, args.rewrite);
-      const output = formatTransformResult(args.code, transformed, editCount);
+      const { transformed, editCount } = transformCode(args2.code, args2.lang, args2.pattern, args2.rewrite);
+      const output = formatTransformResult(args2.code, transformed, editCount);
       showOutputToUser(context, output);
       return output;
     } catch (e) {
@@ -15241,11 +18598,11 @@ import { existsSync as existsSync4 } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
-function findExecutable(name) {
+function findExecutable(name2) {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? "where" : "which";
   try {
-    const result = spawnSync(cmd, [name], { encoding: "utf-8", timeout: 5000 });
+    const result = spawnSync(cmd, [name2], { encoding: "utf-8", timeout: 5000 });
     if (result.status === 0 && result.stdout.trim()) {
       return result.stdout.trim().split(`
 `)[0];
@@ -15309,7 +18666,7 @@ var GREP_SAFETY_FLAGS = ["-n", "-H", "--color=never"];
 
 // src/tools/safe-grep/cli.ts
 function buildRgArgs(options) {
-  const args = [
+  const args2 = [
     ...RG_SAFETY_FLAGS,
     `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
     `--max-filesize=${options.maxFilesize ?? DEFAULT_MAX_FILESIZE}`,
@@ -15317,60 +18674,60 @@ function buildRgArgs(options) {
     `--max-columns=${Math.min(options.maxColumns ?? DEFAULT_MAX_COLUMNS, DEFAULT_MAX_COLUMNS)}`
   ];
   if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`);
+    args2.push(`-C${Math.min(options.context, 10)}`);
   }
   if (options.caseSensitive)
-    args.push("--case-sensitive");
+    args2.push("--case-sensitive");
   if (options.wholeWord)
-    args.push("-w");
+    args2.push("-w");
   if (options.fixedStrings)
-    args.push("-F");
+    args2.push("-F");
   if (options.multiline)
-    args.push("-U");
+    args2.push("-U");
   if (options.hidden)
-    args.push("--hidden");
+    args2.push("--hidden");
   if (options.noIgnore)
-    args.push("--no-ignore");
+    args2.push("--no-ignore");
   if (options.fileType?.length) {
     for (const type of options.fileType) {
-      args.push(`--type=${type}`);
+      args2.push(`--type=${type}`);
     }
   }
   if (options.globs) {
     for (const glob of options.globs) {
-      args.push(`--glob=${glob}`);
+      args2.push(`--glob=${glob}`);
     }
   }
   if (options.excludeGlobs) {
     for (const glob of options.excludeGlobs) {
-      args.push(`--glob=!${glob}`);
+      args2.push(`--glob=!${glob}`);
     }
   }
-  return args;
+  return args2;
 }
 function buildGrepArgs(options) {
-  const args = [...GREP_SAFETY_FLAGS, "-r"];
+  const args2 = [...GREP_SAFETY_FLAGS, "-r"];
   if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`);
+    args2.push(`-C${Math.min(options.context, 10)}`);
   }
   if (!options.caseSensitive)
-    args.push("-i");
+    args2.push("-i");
   if (options.wholeWord)
-    args.push("-w");
+    args2.push("-w");
   if (options.fixedStrings)
-    args.push("-F");
+    args2.push("-F");
   if (options.globs?.length) {
     for (const glob of options.globs) {
-      args.push(`--include=${glob}`);
+      args2.push(`--include=${glob}`);
     }
   }
   if (options.excludeGlobs?.length) {
     for (const glob of options.excludeGlobs) {
-      args.push(`--exclude=${glob}`);
+      args2.push(`--exclude=${glob}`);
     }
   }
-  args.push("--exclude-dir=.git", "--exclude-dir=node_modules");
-  return args;
+  args2.push("--exclude-dir=.git", "--exclude-dir=node_modules");
+  return args2;
 }
 function buildArgs(options, backend) {
   return backend === "rg" ? buildRgArgs(options) : buildGrepArgs(options);
@@ -15397,16 +18754,16 @@ function parseOutput(output) {
 }
 async function runRg(options) {
   const cli = resolveGrepCli();
-  const args = buildArgs(options, cli.backend);
+  const args2 = buildArgs(options, cli.backend);
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS);
   if (cli.backend === "rg") {
-    args.push("--", options.pattern);
+    args2.push("--", options.pattern);
   } else {
-    args.push("-e", options.pattern);
+    args2.push("-e", options.pattern);
   }
   const paths = options.paths?.length ? options.paths : ["."];
-  args.push(...paths);
-  const proc = spawn3([cli.path, ...args], {
+  args2.push(...paths);
+  const proc = spawn3([cli.path, ...args2], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -15490,12 +18847,12 @@ var safe_grep = tool({
     include: tool.schema.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
     path: tool.schema.string().optional().describe("The directory to search in. Defaults to the current working directory.")
   },
-  execute: async (args) => {
+  execute: async (args2) => {
     try {
-      const globs = args.include ? [args.include] : undefined;
-      const paths = args.path ? [args.path] : undefined;
+      const globs = args2.include ? [args2.include] : undefined;
+      const paths = args2.path ? [args2.path] : undefined;
       const result = await runRg({
-        pattern: args.pattern,
+        pattern: args2.pattern,
         paths,
         globs,
         context: 0
@@ -15549,9 +18906,9 @@ var allBuiltinMcps = {
 };
 function createBuiltinMcps(disabledMcps = []) {
   const mcps = {};
-  for (const [name, config3] of Object.entries(allBuiltinMcps)) {
-    if (!disabledMcps.includes(name)) {
-      mcps[name] = config3;
+  for (const [name2, config3] of Object.entries(allBuiltinMcps)) {
+    if (!disabledMcps.includes(name2)) {
+      mcps[name2] = config3;
     }
   }
   return mcps;
@@ -15597,7 +18954,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   agents: AgentOverridesSchema.optional()
 });
 // src/index.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
 function loadPluginConfig(directory) {
   const configPaths = [
@@ -15606,8 +18963,8 @@ function loadPluginConfig(directory) {
   ];
   for (const configPath of configPaths) {
     try {
-      if (fs.existsSync(configPath)) {
-        const content = fs.readFileSync(configPath, "utf-8");
+      if (fs2.existsSync(configPath)) {
+        const content = fs2.readFileSync(configPath, "utf-8");
         const rawConfig = JSON.parse(content);
         const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
         if (!result.success) {
@@ -15627,6 +18984,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
   const contextWindowMonitor = createContextWindowMonitorHook(ctx);
   const sessionRecovery = createSessionRecoveryHook(ctx);
+  const commentChecker = createCommentCheckerHooks();
   updateTerminalTitle({ sessionId: "main" });
   const pluginConfig = loadPluginConfig(ctx.directory);
   let mainSessionID;
@@ -15726,7 +19084,8 @@ var OhMyOpenCodePlugin = async (ctx) => {
         }
       }
     },
-    "tool.execute.before": async (input, _output) => {
+    "tool.execute.before": async (input, output) => {
+      await commentChecker["tool.execute.before"](input, output);
       if (input.sessionID === mainSessionID) {
         updateTerminalTitle({
           sessionId: input.sessionID,
@@ -15739,6 +19098,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
     },
     "tool.execute.after": async (input, output) => {
       await contextWindowMonitor["tool.execute.after"](input, output);
+      await commentChecker["tool.execute.after"](input, output);
       if (input.sessionID === mainSessionID) {
         updateTerminalTitle({
           sessionId: input.sessionID,