energy-state-analyzer 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +116 -0
  3. package/dist/cli.js +1 -0
  4. package/dist/cli.js.map +1 -0
  5. package/grammars/tree-sitter-fsharp.wasm +0 -0
  6. package/grammars/tree-sitter-python.wasm +0 -0
  7. package/grammars/tree-sitter-typescript.wasm +0 -0
  8. package/package.json +169 -0
package/dist/cli.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"cli.js","mappings":"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","sources":["webpack://energy-state-analyzer/./src/core/detectors/cognitive.ts","webpack://energy-state-analyzer/./node_modules/web-tree-sitter/tree-sitter.cjs","webpack://energy-state-analyzer/./src/core/detectors/cyclomatic.ts","webpack://energy-state-analyzer/./src/core/detectors/primitiveObsession.ts","webpack://energy-state-analyzer/./src/cli.ts","webpack://energy-state-analyzer/./src/core/detectors/nesting.ts","webpack://energy-state-analyzer/./src/languages/typescript.ts","webpack://energy-state-analyzer/./src/core/position.ts","webpack://energy-state-analyzer/./src/types.ts","webpack://energy-state-analyzer/./src/core/detectors/parameterCount.ts","webpack://energy-state-analyzer/./src/core/detectors/logicalControlFlow.ts","webpack://energy-state-analyzer/./src/core/detectors/coherence.ts","webpack://energy-state-analyzer/./src/core/detectors/matchOpportunity.ts","webpack://energy-state-analyzer/external node-commonjs \"fs\"","webpack://energy-state-analyzer/./src/core/detectors/inversion.ts","webpack://energy-state-analyzer/./src/languages/index.ts","webpack://energy-state-analyzer/external node-commonjs \"path\"","webpack://energy-state-analyzer/external node-commonjs \"fs/promises\"","webpack://energy-state-analyzer/./src/core/detectors/magicValues.ts","webpack://energy-state-analyzer/./src/core/analyze.ts","webpack://energy-state-analyzer/./src/languages/fsharp.ts","webpack://energy-state-analyzer/./src/languages/python.ts","webpack://energy-state-analyzer/webpack/bootstrap","webpack://energy-state-analyzer/webpack/runtime/create fake namespace object","webpack://energy-state-analyzer/webpack/runtime/define property getters","webpack://energy-state-analyzer/webpack/runtime/hasOwnProperty shorthand","webpack://energy-state-analyzer/webpack/runtime/make namespace object","webpack://energy-state-analyzer/webpack/startup"],"sourcesContent":["import { ComplexityHotspot, EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\n// Cognitive complexity (SonarSource): unlike cyclomatic complexity, every\n// decision point is weighted by how deeply it is nested, and early-return\n// guard clauses are not penalized. This tracks how hard code is to *read*,\n// not just how many paths it has.\n//\n// decision: implements a simplified subset of the SonarSource spec rather than the full algorithm, acceptable for a first pass:\n// assumption: `for`/`while` `else` clauses (where a grammar has them) are scored like `if`/`else`, even though they aren't really a decision point\n// assumption: boolean operator chain merging (\"a and b and c\" = one increment) only checks the immediate parent's operator, not the full chain direction\n// assumption: recursive calls to the enclosing function are not specially detected\n// assumption: match/switch-like constructs and try/except are scored once as a whole, not per-case — see each LanguageAdapter for exact node-type mapping\nexport function calculateCognitiveComplexity(\n functionNode: any,\n language: LanguageAdapter,\n onContribution?: (node: any, amount: number) => void\n): number {\n let score = 0;\n const { nodeTypes } = language;\n\n function add(node: any, amount: number) {\n score += amount;\n onContribution?.(node, amount);\n }\n\n function walkNested(node: any, nesting: number) {\n for (const child of node.children) {\n walk(child, language.entersNestedScope(child) ? nesting + 1 : nesting);\n }\n }\n\n function walk(node: any, nesting: number) {\n const booleanOperator = language.getBooleanOperator(node);\n if (booleanOperator) {\n const parentOperator = language.getBooleanOperator(node.parent);\n if (parentOperator !== booleanOperator) {\n add(node, 1);\n }\n for (const child of node.children) {\n walk(child, nesting);\n }\n return;\n }\n\n if (language.cognitiveNestedDecisionTypes.includes(node.type)) {\n add(node, 1 + nesting);\n walkNested(node, nesting);\n return;\n }\n\n if (node.type === nodeTypes.elseClause) {\n add(node, 1); // flat: no extra nesting increment for the else itself\n walkNested(node, nesting);\n return;\n }\n\n if (node.type === nodeTypes.conditionalExpression) { // ternary: \"a if cond else b\"\n add(node, 1 + nesting);\n for (const child of node.children) {\n walk(child, nesting + 1);\n }\n return;\n }\n\n if (language.isFunctionDefinition(node)) {\n // invariant: only the structural nesting increment for a nested named function/method counts here — its body is scored as its own separate violation by analyzeCognitiveComplexity's traversal, never folded into the enclosing function's score\n add(node, 1 + nesting);\n return;\n }\n\n if (node.type === nodeTypes.lambda) {\n // decision: attributes a lambda's body complexity to the enclosing function instead of scoring it separately, since lambdas aren't analyzed as their own function (see LanguageAdapter docs)\n add(node, 1 + nesting);\n walkNested(node, nesting);\n return;\n }\n\n for (const child of node.children || []) {\n walk(child, nesting);\n }\n }\n\n for (const child of functionNode.children) {\n walk(child, 0);\n }\n\n return score;\n}\n\n// Re-runs the same walk used for scoring, but records where each point of\n// score comes from so callers can render a per-line heatmap across the\n// function body instead of a single flat highlight.\nexport function findCognitiveHotspots(functionNode: any, positions: PositionLookup, language: LanguageAdapter): ComplexityHotspot[] {\n const hotspots: ComplexityHotspot[] = [];\n calculateCognitiveComplexity(functionNode, language, (node, amount) => {\n hotspots.push({ line: positions.toPosition(node.startIndex).line, weight: amount });\n });\n return hotspots;\n}\n\nexport interface CognitiveThresholds {\n mediumThreshold: number;\n highThreshold: number;\n}\n\nexport const DEFAULT_COGNITIVE_THRESHOLDS: CognitiveThresholds = {\n mediumThreshold: 15,\n highThreshold: 25\n};\n\nexport function analyzeCognitiveComplexity(\n tree: any,\n positions: PositionLookup,\n language: LanguageAdapter,\n thresholds: CognitiveThresholds = DEFAULT_COGNITIVE_THRESHOLDS\n): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n\n function traverse(node: any) {\n if (language.isFunctionDefinition(node)) {\n const complexity = calculateCognitiveComplexity(node, language);\n if (complexity > thresholds.mediumThreshold) {\n const position = positions.toPosition(node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.COGNITIVE,\n severity: complexity > thresholds.highThreshold ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n message: `High cognitive complexity: ${complexity}. This function is hard to read; consider flattening nesting or extracting functions.`,\n hotspots: findCognitiveHotspots(node, positions, language)\n });\n }\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","\"use strict\";\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\nvar __commonJS = (cb, mod) => function __require() {\n return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n for (var name2 in all)\n __defProp(target, name2, { get: all[name2], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n if (from && typeof from === \"object\" || typeof from === \"function\") {\n for (let key of __getOwnPropNames(from))\n if (!__hasOwnProp.call(to, key) && key !== except)\n __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n }\n return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n // If the importer is in node compatibility mode or this is not an ESM\n // file that has been converted to a CommonJS file using a Babel-\n // compatible transform (i.e. \"__esModule\" has not been set), then set\n // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n mod\n));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// lib/tree-sitter.cjs\nvar require_tree_sitter = __commonJS({\n \"lib/tree-sitter.cjs\"(exports, module) {\n \"use strict\";\n var Module = (() => {\n var _scriptName = typeof document != \"undefined\" ? document.currentScript?.src : void 0;\n if (typeof __filename != \"undefined\") _scriptName = _scriptName || __filename;\n return async function(moduleArg = {}) {\n var moduleRtn;\n var Module = moduleArg;\n var readyPromiseResolve, readyPromiseReject;\n var readyPromise = new Promise((resolve, reject) => {\n readyPromiseResolve = resolve;\n readyPromiseReject = reject;\n });\n var ENVIRONMENT_IS_WEB = typeof window == \"object\";\n var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != \"undefined\";\n var ENVIRONMENT_IS_NODE = typeof process == \"object\" && typeof process.versions == \"object\" && typeof process.versions.node == \"string\" && process.type != \"renderer\";\n var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;\n if (ENVIRONMENT_IS_NODE) {\n }\n Module.currentQueryProgressCallback = null;\n Module.currentProgressCallback = null;\n Module.currentLogCallback = null;\n Module.currentParseCallback = null;\n var moduleOverrides = Object.assign({}, Module);\n var arguments_ = [];\n var thisProgram = \"./this.program\";\n var quit_ = /* @__PURE__ */ __name((status, toThrow) => {\n throw toThrow;\n }, \"quit_\");\n var scriptDirectory = \"\";\n function locateFile(path) {\n if (Module[\"locateFile\"]) {\n return Module[\"locateFile\"](path, scriptDirectory);\n }\n return scriptDirectory + path;\n }\n __name(locateFile, \"locateFile\");\n var readAsync, readBinary;\n if (ENVIRONMENT_IS_NODE) {\n var fs = require(\"fs\");\n var nodePath = require(\"path\");\n scriptDirectory = __dirname + \"/\";\n readBinary = /* @__PURE__ */ __name((filename) => {\n filename = isFileURI(filename) ? new URL(filename) : filename;\n var ret = fs.readFileSync(filename);\n return ret;\n }, \"readBinary\");\n readAsync = /* @__PURE__ */ __name(async (filename, binary2 = true) => {\n filename = isFileURI(filename) ? new URL(filename) : filename;\n var ret = fs.readFileSync(filename, binary2 ? void 0 : \"utf8\");\n return ret;\n }, \"readAsync\");\n if (!Module[\"thisProgram\"] && process.argv.length > 1) {\n thisProgram = process.argv[1].replace(/\\\\/g, \"/\");\n }\n arguments_ = process.argv.slice(2);\n quit_ = /* @__PURE__ */ __name((status, toThrow) => {\n process.exitCode = status;\n throw toThrow;\n }, \"quit_\");\n } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {\n if (ENVIRONMENT_IS_WORKER) {\n scriptDirectory = self.location.href;\n } else if (typeof document != \"undefined\" && document.currentScript) {\n scriptDirectory = document.currentScript.src;\n }\n if (_scriptName) {\n scriptDirectory = _scriptName;\n }\n if (scriptDirectory.startsWith(\"blob:\")) {\n scriptDirectory = \"\";\n } else {\n scriptDirectory = scriptDirectory.slice(0, scriptDirectory.replace(/[?#].*/, \"\").lastIndexOf(\"/\") + 1);\n }\n {\n if (ENVIRONMENT_IS_WORKER) {\n readBinary = /* @__PURE__ */ __name((url) => {\n var xhr = new XMLHttpRequest();\n xhr.open(\"GET\", url, false);\n xhr.responseType = \"arraybuffer\";\n xhr.send(null);\n return new Uint8Array(\n /** @type{!ArrayBuffer} */\n xhr.response\n );\n }, \"readBinary\");\n }\n readAsync = /* @__PURE__ */ __name(async (url) => {\n if (isFileURI(url)) {\n return new Promise((resolve, reject) => {\n var xhr = new XMLHttpRequest();\n xhr.open(\"GET\", url, true);\n xhr.responseType = \"arraybuffer\";\n xhr.onload = () => {\n if (xhr.status == 200 || xhr.status == 0 && xhr.response) {\n resolve(xhr.response);\n return;\n }\n reject(xhr.status);\n };\n xhr.onerror = reject;\n xhr.send(null);\n });\n }\n var response = await fetch(url, {\n credentials: \"same-origin\"\n });\n if (response.ok) {\n return response.arrayBuffer();\n }\n throw new Error(response.status + \" : \" + response.url);\n }, \"readAsync\");\n }\n } else {\n }\n var out = Module[\"print\"] || console.log.bind(console);\n var err = Module[\"printErr\"] || console.error.bind(console);\n Object.assign(Module, moduleOverrides);\n moduleOverrides = null;\n if (Module[\"arguments\"]) arguments_ = Module[\"arguments\"];\n if (Module[\"thisProgram\"]) thisProgram = Module[\"thisProgram\"];\n var dynamicLibraries = Module[\"dynamicLibraries\"] || [];\n var wasmBinary = Module[\"wasmBinary\"];\n var wasmMemory;\n var ABORT = false;\n var EXITSTATUS;\n function assert(condition, text) {\n if (!condition) {\n abort(text);\n }\n }\n __name(assert, \"assert\");\n var HEAP, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;\n var HEAP_DATA_VIEW;\n var runtimeInitialized = false;\n var isFileURI = /* @__PURE__ */ __name((filename) => filename.startsWith(\"file://\"), \"isFileURI\");\n function updateMemoryViews() {\n var b = wasmMemory.buffer;\n Module[\"HEAP_DATA_VIEW\"] = HEAP_DATA_VIEW = new DataView(b);\n Module[\"HEAP8\"] = HEAP8 = new Int8Array(b);\n Module[\"HEAP16\"] = HEAP16 = new Int16Array(b);\n Module[\"HEAPU8\"] = HEAPU8 = new Uint8Array(b);\n Module[\"HEAPU16\"] = HEAPU16 = new Uint16Array(b);\n Module[\"HEAP32\"] = HEAP32 = new Int32Array(b);\n Module[\"HEAPU32\"] = HEAPU32 = new Uint32Array(b);\n Module[\"HEAPF32\"] = HEAPF32 = new Float32Array(b);\n Module[\"HEAPF64\"] = HEAPF64 = new Float64Array(b);\n Module[\"HEAP64\"] = HEAP64 = new BigInt64Array(b);\n Module[\"HEAPU64\"] = HEAPU64 = new BigUint64Array(b);\n }\n __name(updateMemoryViews, \"updateMemoryViews\");\n if (Module[\"wasmMemory\"]) {\n wasmMemory = Module[\"wasmMemory\"];\n } else {\n var INITIAL_MEMORY = Module[\"INITIAL_MEMORY\"] || 33554432;\n wasmMemory = new WebAssembly.Memory({\n \"initial\": INITIAL_MEMORY / 65536,\n // In theory we should not need to emit the maximum if we want \"unlimited\"\n // or 4GB of memory, but VMs error on that atm, see\n // https://github.com/emscripten-core/emscripten/issues/14130\n // And in the pthreads case we definitely need to emit a maximum. So\n // always emit one.\n \"maximum\": 32768\n });\n }\n updateMemoryViews();\n var __RELOC_FUNCS__ = [];\n function preRun() {\n if (Module[\"preRun\"]) {\n if (typeof Module[\"preRun\"] == \"function\") Module[\"preRun\"] = [Module[\"preRun\"]];\n while (Module[\"preRun\"].length) {\n addOnPreRun(Module[\"preRun\"].shift());\n }\n }\n callRuntimeCallbacks(onPreRuns);\n }\n __name(preRun, \"preRun\");\n function initRuntime() {\n runtimeInitialized = true;\n callRuntimeCallbacks(__RELOC_FUNCS__);\n wasmExports[\"__wasm_call_ctors\"]();\n callRuntimeCallbacks(onPostCtors);\n }\n __name(initRuntime, \"initRuntime\");\n function preMain() {\n }\n __name(preMain, \"preMain\");\n function postRun() {\n if (Module[\"postRun\"]) {\n if (typeof Module[\"postRun\"] == \"function\") Module[\"postRun\"] = [Module[\"postRun\"]];\n while (Module[\"postRun\"].length) {\n addOnPostRun(Module[\"postRun\"].shift());\n }\n }\n callRuntimeCallbacks(onPostRuns);\n }\n __name(postRun, \"postRun\");\n var runDependencies = 0;\n var dependenciesFulfilled = null;\n function getUniqueRunDependency(id) {\n return id;\n }\n __name(getUniqueRunDependency, \"getUniqueRunDependency\");\n function addRunDependency(id) {\n runDependencies++;\n Module[\"monitorRunDependencies\"]?.(runDependencies);\n }\n __name(addRunDependency, \"addRunDependency\");\n function removeRunDependency(id) {\n runDependencies--;\n Module[\"monitorRunDependencies\"]?.(runDependencies);\n if (runDependencies == 0) {\n if (dependenciesFulfilled) {\n var callback = dependenciesFulfilled;\n dependenciesFulfilled = null;\n callback();\n }\n }\n }\n __name(removeRunDependency, \"removeRunDependency\");\n function abort(what) {\n Module[\"onAbort\"]?.(what);\n what = \"Aborted(\" + what + \")\";\n err(what);\n ABORT = true;\n what += \". Build with -sASSERTIONS for more info.\";\n var e = new WebAssembly.RuntimeError(what);\n readyPromiseReject(e);\n throw e;\n }\n __name(abort, \"abort\");\n var wasmBinaryFile;\n function findWasmBinary() {\n return locateFile(\"tree-sitter.wasm\");\n }\n __name(findWasmBinary, \"findWasmBinary\");\n function getBinarySync(file) {\n if (file == wasmBinaryFile && wasmBinary) {\n return new Uint8Array(wasmBinary);\n }\n if (readBinary) {\n return readBinary(file);\n }\n throw \"both async and sync fetching of the wasm failed\";\n }\n __name(getBinarySync, \"getBinarySync\");\n async function getWasmBinary(binaryFile) {\n if (!wasmBinary) {\n try {\n var response = await readAsync(binaryFile);\n return new Uint8Array(response);\n } catch {\n }\n }\n return getBinarySync(binaryFile);\n }\n __name(getWasmBinary, \"getWasmBinary\");\n async function instantiateArrayBuffer(binaryFile, imports) {\n try {\n var binary2 = await getWasmBinary(binaryFile);\n var instance2 = await WebAssembly.instantiate(binary2, imports);\n return instance2;\n } catch (reason) {\n err(`failed to asynchronously prepare wasm: ${reason}`);\n abort(reason);\n }\n }\n __name(instantiateArrayBuffer, \"instantiateArrayBuffer\");\n async function instantiateAsync(binary2, binaryFile, imports) {\n if (!binary2 && typeof WebAssembly.instantiateStreaming == \"function\" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {\n try {\n var response = fetch(binaryFile, {\n credentials: \"same-origin\"\n });\n var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);\n return instantiationResult;\n } catch (reason) {\n err(`wasm streaming compile failed: ${reason}`);\n err(\"falling back to ArrayBuffer instantiation\");\n }\n }\n return instantiateArrayBuffer(binaryFile, imports);\n }\n __name(instantiateAsync, \"instantiateAsync\");\n function getWasmImports() {\n return {\n \"env\": wasmImports,\n \"wasi_snapshot_preview1\": wasmImports,\n \"GOT.mem\": new Proxy(wasmImports, GOTHandler),\n \"GOT.func\": new Proxy(wasmImports, GOTHandler)\n };\n }\n __name(getWasmImports, \"getWasmImports\");\n async function createWasm() {\n function receiveInstance(instance2, module2) {\n wasmExports = instance2.exports;\n wasmExports = relocateExports(wasmExports, 1024);\n var metadata2 = getDylinkMetadata(module2);\n if (metadata2.neededDynlibs) {\n dynamicLibraries = metadata2.neededDynlibs.concat(dynamicLibraries);\n }\n mergeLibSymbols(wasmExports, \"main\");\n LDSO.init();\n loadDylibs();\n __RELOC_FUNCS__.push(wasmExports[\"__wasm_apply_data_relocs\"]);\n removeRunDependency(\"wasm-instantiate\");\n return wasmExports;\n }\n __name(receiveInstance, \"receiveInstance\");\n addRunDependency(\"wasm-instantiate\");\n function receiveInstantiationResult(result2) {\n return receiveInstance(result2[\"instance\"], result2[\"module\"]);\n }\n __name(receiveInstantiationResult, \"receiveInstantiationResult\");\n var info2 = getWasmImports();\n if (Module[\"instantiateWasm\"]) {\n return new Promise((resolve, reject) => {\n Module[\"instantiateWasm\"](info2, (mod, inst) => {\n receiveInstance(mod, inst);\n resolve(mod.exports);\n });\n });\n }\n wasmBinaryFile ??= findWasmBinary();\n try {\n var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info2);\n var exports2 = receiveInstantiationResult(result);\n return exports2;\n } catch (e) {\n readyPromiseReject(e);\n return Promise.reject(e);\n }\n }\n __name(createWasm, \"createWasm\");\n var ASM_CONSTS = {};\n class ExitStatus {\n static {\n __name(this, \"ExitStatus\");\n }\n name = \"ExitStatus\";\n constructor(status) {\n this.message = `Program terminated with exit(${status})`;\n this.status = status;\n }\n }\n var GOT = {};\n var currentModuleWeakSymbols = /* @__PURE__ */ new Set([]);\n var GOTHandler = {\n get(obj, symName) {\n var rtn = GOT[symName];\n if (!rtn) {\n rtn = GOT[symName] = new WebAssembly.Global({\n \"value\": \"i32\",\n \"mutable\": true\n });\n }\n if (!currentModuleWeakSymbols.has(symName)) {\n rtn.required = true;\n }\n return rtn;\n }\n };\n var LE_HEAP_LOAD_F32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getFloat32(byteOffset, true), \"LE_HEAP_LOAD_F32\");\n var LE_HEAP_LOAD_F64 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getFloat64(byteOffset, true), \"LE_HEAP_LOAD_F64\");\n var LE_HEAP_LOAD_I16 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getInt16(byteOffset, true), \"LE_HEAP_LOAD_I16\");\n var LE_HEAP_LOAD_I32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getInt32(byteOffset, true), \"LE_HEAP_LOAD_I32\");\n var LE_HEAP_LOAD_U16 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getUint16(byteOffset, true), \"LE_HEAP_LOAD_U16\");\n var LE_HEAP_LOAD_U32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getUint32(byteOffset, true), \"LE_HEAP_LOAD_U32\");\n var LE_HEAP_STORE_F32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setFloat32(byteOffset, value, true), \"LE_HEAP_STORE_F32\");\n var LE_HEAP_STORE_F64 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setFloat64(byteOffset, value, true), \"LE_HEAP_STORE_F64\");\n var LE_HEAP_STORE_I16 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setInt16(byteOffset, value, true), \"LE_HEAP_STORE_I16\");\n var LE_HEAP_STORE_I32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setInt32(byteOffset, value, true), \"LE_HEAP_STORE_I32\");\n var LE_HEAP_STORE_U16 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setUint16(byteOffset, value, true), \"LE_HEAP_STORE_U16\");\n var LE_HEAP_STORE_U32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setUint32(byteOffset, value, true), \"LE_HEAP_STORE_U32\");\n var callRuntimeCallbacks = /* @__PURE__ */ __name((callbacks) => {\n while (callbacks.length > 0) {\n callbacks.shift()(Module);\n }\n }, \"callRuntimeCallbacks\");\n var onPostRuns = [];\n var addOnPostRun = /* @__PURE__ */ __name((cb) => onPostRuns.unshift(cb), \"addOnPostRun\");\n var onPreRuns = [];\n var addOnPreRun = /* @__PURE__ */ __name((cb) => onPreRuns.unshift(cb), \"addOnPreRun\");\n var UTF8Decoder = typeof TextDecoder != \"undefined\" ? new TextDecoder() : void 0;\n var UTF8ArrayToString = /* @__PURE__ */ __name((heapOrArray, idx = 0, maxBytesToRead = NaN) => {\n var endIdx = idx + maxBytesToRead;\n var endPtr = idx;\n while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;\n if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {\n return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));\n }\n var str = \"\";\n while (idx < endPtr) {\n var u0 = heapOrArray[idx++];\n if (!(u0 & 128)) {\n str += String.fromCharCode(u0);\n continue;\n }\n var u1 = heapOrArray[idx++] & 63;\n if ((u0 & 224) == 192) {\n str += String.fromCharCode((u0 & 31) << 6 | u1);\n continue;\n }\n var u2 = heapOrArray[idx++] & 63;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;\n }\n if (u0 < 65536) {\n str += String.fromCharCode(u0);\n } else {\n var ch = u0 - 65536;\n str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);\n }\n }\n return str;\n }, \"UTF8ArrayToString\");\n var getDylinkMetadata = /* @__PURE__ */ __name((binary2) => {\n var offset = 0;\n var end = 0;\n function getU8() {\n return binary2[offset++];\n }\n __name(getU8, \"getU8\");\n function getLEB() {\n var ret = 0;\n var mul = 1;\n while (1) {\n var byte = binary2[offset++];\n ret += (byte & 127) * mul;\n mul *= 128;\n if (!(byte & 128)) break;\n }\n return ret;\n }\n __name(getLEB, \"getLEB\");\n function getString() {\n var len = getLEB();\n offset += len;\n return UTF8ArrayToString(binary2, offset - len, len);\n }\n __name(getString, \"getString\");\n function failIf(condition, message) {\n if (condition) throw new Error(message);\n }\n __name(failIf, \"failIf\");\n var name2 = \"dylink.0\";\n if (binary2 instanceof WebAssembly.Module) {\n var dylinkSection = WebAssembly.Module.customSections(binary2, name2);\n if (dylinkSection.length === 0) {\n name2 = \"dylink\";\n dylinkSection = WebAssembly.Module.customSections(binary2, name2);\n }\n failIf(dylinkSection.length === 0, \"need dylink section\");\n binary2 = new Uint8Array(dylinkSection[0]);\n end = binary2.length;\n } else {\n var int32View = new Uint32Array(new Uint8Array(binary2.subarray(0, 24)).buffer);\n var magicNumberFound = int32View[0] == 1836278016 || int32View[0] == 6386541;\n failIf(!magicNumberFound, \"need to see wasm magic number\");\n failIf(binary2[8] !== 0, \"need the dylink section to be first\");\n offset = 9;\n var section_size = getLEB();\n end = offset + section_size;\n name2 = getString();\n }\n var customSection = {\n neededDynlibs: [],\n tlsExports: /* @__PURE__ */ new Set(),\n weakImports: /* @__PURE__ */ new Set()\n };\n if (name2 == \"dylink\") {\n customSection.memorySize = getLEB();\n customSection.memoryAlign = getLEB();\n customSection.tableSize = getLEB();\n customSection.tableAlign = getLEB();\n var neededDynlibsCount = getLEB();\n for (var i2 = 0; i2 < neededDynlibsCount; ++i2) {\n var libname = getString();\n customSection.neededDynlibs.push(libname);\n }\n } else {\n failIf(name2 !== \"dylink.0\");\n var WASM_DYLINK_MEM_INFO = 1;\n var WASM_DYLINK_NEEDED = 2;\n var WASM_DYLINK_EXPORT_INFO = 3;\n var WASM_DYLINK_IMPORT_INFO = 4;\n var WASM_SYMBOL_TLS = 256;\n var WASM_SYMBOL_BINDING_MASK = 3;\n var WASM_SYMBOL_BINDING_WEAK = 1;\n while (offset < end) {\n var subsectionType = getU8();\n var subsectionSize = getLEB();\n if (subsectionType === WASM_DYLINK_MEM_INFO) {\n customSection.memorySize = getLEB();\n customSection.memoryAlign = getLEB();\n customSection.tableSize = getLEB();\n customSection.tableAlign = getLEB();\n } else if (subsectionType === WASM_DYLINK_NEEDED) {\n var neededDynlibsCount = getLEB();\n for (var i2 = 0; i2 < neededDynlibsCount; ++i2) {\n libname = getString();\n customSection.neededDynlibs.push(libname);\n }\n } else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {\n var count = getLEB();\n while (count--) {\n var symname = getString();\n var flags2 = getLEB();\n if (flags2 & WASM_SYMBOL_TLS) {\n customSection.tlsExports.add(symname);\n }\n }\n } else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {\n var count = getLEB();\n while (count--) {\n var modname = getString();\n var symname = getString();\n var flags2 = getLEB();\n if ((flags2 & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {\n customSection.weakImports.add(symname);\n }\n }\n } else {\n offset += subsectionSize;\n }\n }\n }\n return customSection;\n }, \"getDylinkMetadata\");\n function getValue(ptr, type = \"i8\") {\n if (type.endsWith(\"*\")) type = \"*\";\n switch (type) {\n case \"i1\":\n return HEAP8[ptr];\n case \"i8\":\n return HEAP8[ptr];\n case \"i16\":\n return LE_HEAP_LOAD_I16((ptr >> 1) * 2);\n case \"i32\":\n return LE_HEAP_LOAD_I32((ptr >> 2) * 4);\n case \"i64\":\n return HEAP64[ptr >> 3];\n case \"float\":\n return LE_HEAP_LOAD_F32((ptr >> 2) * 4);\n case \"double\":\n return LE_HEAP_LOAD_F64((ptr >> 3) * 8);\n case \"*\":\n return LE_HEAP_LOAD_U32((ptr >> 2) * 4);\n default:\n abort(`invalid type for getValue: ${type}`);\n }\n }\n __name(getValue, \"getValue\");\n var newDSO = /* @__PURE__ */ __name((name2, handle2, syms) => {\n var dso = {\n refcount: Infinity,\n name: name2,\n exports: syms,\n global: true\n };\n LDSO.loadedLibsByName[name2] = dso;\n if (handle2 != void 0) {\n LDSO.loadedLibsByHandle[handle2] = dso;\n }\n return dso;\n }, \"newDSO\");\n var LDSO = {\n loadedLibsByName: {},\n loadedLibsByHandle: {},\n init() {\n newDSO(\"__main__\", 0, wasmImports);\n }\n };\n var ___heap_base = 78224;\n var alignMemory = /* @__PURE__ */ __name((size, alignment) => Math.ceil(size / alignment) * alignment, \"alignMemory\");\n var getMemory = /* @__PURE__ */ __name((size) => {\n if (runtimeInitialized) {\n return _calloc(size, 1);\n }\n var ret = ___heap_base;\n var end = ret + alignMemory(size, 16);\n ___heap_base = end;\n GOT[\"__heap_base\"].value = end;\n return ret;\n }, \"getMemory\");\n var isInternalSym = /* @__PURE__ */ __name((symName) => [\"__cpp_exception\", \"__c_longjmp\", \"__wasm_apply_data_relocs\", \"__dso_handle\", \"__tls_size\", \"__tls_align\", \"__set_stack_limits\", \"_emscripten_tls_init\", \"__wasm_init_tls\", \"__wasm_call_ctors\", \"__start_em_asm\", \"__stop_em_asm\", \"__start_em_js\", \"__stop_em_js\"].includes(symName) || symName.startsWith(\"__em_js__\"), \"isInternalSym\");\n var uleb128Encode = /* @__PURE__ */ __name((n, target) => {\n if (n < 128) {\n target.push(n);\n } else {\n target.push(n % 128 | 128, n >> 7);\n }\n }, \"uleb128Encode\");\n var sigToWasmTypes = /* @__PURE__ */ __name((sig) => {\n var typeNames = {\n \"i\": \"i32\",\n \"j\": \"i64\",\n \"f\": \"f32\",\n \"d\": \"f64\",\n \"e\": \"externref\",\n \"p\": \"i32\"\n };\n var type = {\n parameters: [],\n results: sig[0] == \"v\" ? [] : [typeNames[sig[0]]]\n };\n for (var i2 = 1; i2 < sig.length; ++i2) {\n type.parameters.push(typeNames[sig[i2]]);\n }\n return type;\n }, \"sigToWasmTypes\");\n var generateFuncType = /* @__PURE__ */ __name((sig, target) => {\n var sigRet = sig.slice(0, 1);\n var sigParam = sig.slice(1);\n var typeCodes = {\n \"i\": 127,\n // i32\n \"p\": 127,\n // i32\n \"j\": 126,\n // i64\n \"f\": 125,\n // f32\n \"d\": 124,\n // f64\n \"e\": 111\n };\n target.push(96);\n uleb128Encode(sigParam.length, target);\n for (var i2 = 0; i2 < sigParam.length; ++i2) {\n target.push(typeCodes[sigParam[i2]]);\n }\n if (sigRet == \"v\") {\n target.push(0);\n } else {\n target.push(1, typeCodes[sigRet]);\n }\n }, \"generateFuncType\");\n var convertJsFunctionToWasm = /* @__PURE__ */ __name((func2, sig) => {\n if (typeof WebAssembly.Function == \"function\") {\n return new WebAssembly.Function(sigToWasmTypes(sig), func2);\n }\n var typeSectionBody = [1];\n generateFuncType(sig, typeSectionBody);\n var bytes = [\n 0,\n 97,\n 115,\n 109,\n // magic (\"\\0asm\")\n 1,\n 0,\n 0,\n 0,\n // version: 1\n 1\n ];\n uleb128Encode(typeSectionBody.length, bytes);\n bytes.push(...typeSectionBody);\n bytes.push(\n 2,\n 7,\n // import section\n // (import \"e\" \"f\" (func 0 (type 0)))\n 1,\n 1,\n 101,\n 1,\n 102,\n 0,\n 0,\n 7,\n 5,\n // export section\n // (export \"f\" (func 0 (type 0)))\n 1,\n 1,\n 102,\n 0,\n 0\n );\n var module2 = new WebAssembly.Module(new Uint8Array(bytes));\n var instance2 = new WebAssembly.Instance(module2, {\n \"e\": {\n \"f\": func2\n }\n });\n var wrappedFunc = instance2.exports[\"f\"];\n return wrappedFunc;\n }, \"convertJsFunctionToWasm\");\n var wasmTableMirror = [];\n var wasmTable = new WebAssembly.Table({\n \"initial\": 31,\n \"element\": \"anyfunc\"\n });\n var getWasmTableEntry = /* @__PURE__ */ __name((funcPtr) => {\n var func2 = wasmTableMirror[funcPtr];\n if (!func2) {\n if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;\n wasmTableMirror[funcPtr] = func2 = wasmTable.get(funcPtr);\n }\n return func2;\n }, \"getWasmTableEntry\");\n var updateTableMap = /* @__PURE__ */ __name((offset, count) => {\n if (functionsInTableMap) {\n for (var i2 = offset; i2 < offset + count; i2++) {\n var item = getWasmTableEntry(i2);\n if (item) {\n functionsInTableMap.set(item, i2);\n }\n }\n }\n }, \"updateTableMap\");\n var functionsInTableMap;\n var getFunctionAddress = /* @__PURE__ */ __name((func2) => {\n if (!functionsInTableMap) {\n functionsInTableMap = /* @__PURE__ */ new WeakMap();\n updateTableMap(0, wasmTable.length);\n }\n return functionsInTableMap.get(func2) || 0;\n }, \"getFunctionAddress\");\n var freeTableIndexes = [];\n var getEmptyTableSlot = /* @__PURE__ */ __name(() => {\n if (freeTableIndexes.length) {\n return freeTableIndexes.pop();\n }\n try {\n wasmTable.grow(1);\n } catch (err2) {\n if (!(err2 instanceof RangeError)) {\n throw err2;\n }\n throw \"Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.\";\n }\n return wasmTable.length - 1;\n }, \"getEmptyTableSlot\");\n var setWasmTableEntry = /* @__PURE__ */ __name((idx, func2) => {\n wasmTable.set(idx, func2);\n wasmTableMirror[idx] = wasmTable.get(idx);\n }, \"setWasmTableEntry\");\n var addFunction = /* @__PURE__ */ __name((func2, sig) => {\n var rtn = getFunctionAddress(func2);\n if (rtn) {\n return rtn;\n }\n var ret = getEmptyTableSlot();\n try {\n setWasmTableEntry(ret, func2);\n } catch (err2) {\n if (!(err2 instanceof TypeError)) {\n throw err2;\n }\n var wrapped = convertJsFunctionToWasm(func2, sig);\n setWasmTableEntry(ret, wrapped);\n }\n functionsInTableMap.set(func2, ret);\n return ret;\n }, \"addFunction\");\n var updateGOT = /* @__PURE__ */ __name((exports2, replace) => {\n for (var symName in exports2) {\n if (isInternalSym(symName)) {\n continue;\n }\n var value = exports2[symName];\n GOT[symName] ||= new WebAssembly.Global({\n \"value\": \"i32\",\n \"mutable\": true\n });\n if (replace || GOT[symName].value == 0) {\n if (typeof value == \"function\") {\n GOT[symName].value = addFunction(value);\n } else if (typeof value == \"number\") {\n GOT[symName].value = value;\n } else {\n err(`unhandled export type for '${symName}': ${typeof value}`);\n }\n }\n }\n }, \"updateGOT\");\n var relocateExports = /* @__PURE__ */ __name((exports2, memoryBase2, replace) => {\n var relocated = {};\n for (var e in exports2) {\n var value = exports2[e];\n if (typeof value == \"object\") {\n value = value.value;\n }\n if (typeof value == \"number\") {\n value += memoryBase2;\n }\n relocated[e] = value;\n }\n updateGOT(relocated, replace);\n return relocated;\n }, \"relocateExports\");\n var isSymbolDefined = /* @__PURE__ */ __name((symName) => {\n var existing = wasmImports[symName];\n if (!existing || existing.stub) {\n return false;\n }\n return true;\n }, \"isSymbolDefined\");\n var dynCall = /* @__PURE__ */ __name((sig, ptr, args2 = []) => {\n var rtn = getWasmTableEntry(ptr)(...args2);\n return rtn;\n }, \"dynCall\");\n var stackSave = /* @__PURE__ */ __name(() => _emscripten_stack_get_current(), \"stackSave\");\n var stackRestore = /* @__PURE__ */ __name((val) => __emscripten_stack_restore(val), \"stackRestore\");\n var createInvokeFunction = /* @__PURE__ */ __name((sig) => (ptr, ...args2) => {\n var sp = stackSave();\n try {\n return dynCall(sig, ptr, args2);\n } catch (e) {\n stackRestore(sp);\n if (e !== e + 0) throw e;\n _setThrew(1, 0);\n if (sig[0] == \"j\") return 0n;\n }\n }, \"createInvokeFunction\");\n var resolveGlobalSymbol = /* @__PURE__ */ __name((symName, direct = false) => {\n var sym;\n if (isSymbolDefined(symName)) {\n sym = wasmImports[symName];\n } else if (symName.startsWith(\"invoke_\")) {\n sym = wasmImports[symName] = createInvokeFunction(symName.split(\"_\")[1]);\n }\n return {\n sym,\n name: symName\n };\n }, \"resolveGlobalSymbol\");\n var onPostCtors = [];\n var addOnPostCtor = /* @__PURE__ */ __name((cb) => onPostCtors.unshift(cb), \"addOnPostCtor\");\n var UTF8ToString = /* @__PURE__ */ __name((ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : \"\", \"UTF8ToString\");\n var loadWebAssemblyModule = /* @__PURE__ */ __name((binary, flags, libName, localScope, handle) => {\n var metadata = getDylinkMetadata(binary);\n currentModuleWeakSymbols = metadata.weakImports;\n function loadModule() {\n var memAlign = Math.pow(2, metadata.memoryAlign);\n var memoryBase = metadata.memorySize ? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign) : 0;\n var tableBase = metadata.tableSize ? wasmTable.length : 0;\n if (handle) {\n HEAP8[handle + 8] = 1;\n LE_HEAP_STORE_U32((handle + 12 >> 2) * 4, memoryBase);\n LE_HEAP_STORE_I32((handle + 16 >> 2) * 4, metadata.memorySize);\n LE_HEAP_STORE_U32((handle + 20 >> 2) * 4, tableBase);\n LE_HEAP_STORE_I32((handle + 24 >> 2) * 4, metadata.tableSize);\n }\n if (metadata.tableSize) {\n wasmTable.grow(metadata.tableSize);\n }\n var moduleExports;\n function resolveSymbol(sym) {\n var resolved = resolveGlobalSymbol(sym).sym;\n if (!resolved && localScope) {\n resolved = localScope[sym];\n }\n if (!resolved) {\n resolved = moduleExports[sym];\n }\n return resolved;\n }\n __name(resolveSymbol, \"resolveSymbol\");\n var proxyHandler = {\n get(stubs, prop) {\n switch (prop) {\n case \"__memory_base\":\n return memoryBase;\n case \"__table_base\":\n return tableBase;\n }\n if (prop in wasmImports && !wasmImports[prop].stub) {\n var res = wasmImports[prop];\n return res;\n }\n if (!(prop in stubs)) {\n var resolved;\n stubs[prop] = (...args2) => {\n resolved ||= resolveSymbol(prop);\n return resolved(...args2);\n };\n }\n return stubs[prop];\n }\n };\n var proxy = new Proxy({}, proxyHandler);\n var info = {\n \"GOT.mem\": new Proxy({}, GOTHandler),\n \"GOT.func\": new Proxy({}, GOTHandler),\n \"env\": proxy,\n \"wasi_snapshot_preview1\": proxy\n };\n function postInstantiation(module, instance) {\n updateTableMap(tableBase, metadata.tableSize);\n moduleExports = relocateExports(instance.exports, memoryBase);\n if (!flags.allowUndefined) {\n reportUndefinedSymbols();\n }\n function addEmAsm(addr, body) {\n var args = [];\n var arity = 0;\n for (; arity < 16; arity++) {\n if (body.indexOf(\"$\" + arity) != -1) {\n args.push(\"$\" + arity);\n } else {\n break;\n }\n }\n args = args.join(\",\");\n var func = `(${args}) => { ${body} };`;\n ASM_CONSTS[start] = eval(func);\n }\n __name(addEmAsm, \"addEmAsm\");\n if (\"__start_em_asm\" in moduleExports) {\n var start = moduleExports[\"__start_em_asm\"];\n var stop = moduleExports[\"__stop_em_asm\"];\n while (start < stop) {\n var jsString = UTF8ToString(start);\n addEmAsm(start, jsString);\n start = HEAPU8.indexOf(0, start) + 1;\n }\n }\n function addEmJs(name, cSig, body) {\n var jsArgs = [];\n cSig = cSig.slice(1, -1);\n if (cSig != \"void\") {\n cSig = cSig.split(\",\");\n for (var i in cSig) {\n var jsArg = cSig[i].split(\" \").pop();\n jsArgs.push(jsArg.replace(\"*\", \"\"));\n }\n }\n var func = `(${jsArgs}) => ${body};`;\n moduleExports[name] = eval(func);\n }\n __name(addEmJs, \"addEmJs\");\n for (var name in moduleExports) {\n if (name.startsWith(\"__em_js__\")) {\n var start = moduleExports[name];\n var jsString = UTF8ToString(start);\n var parts = jsString.split(\"<::>\");\n addEmJs(name.replace(\"__em_js__\", \"\"), parts[0], parts[1]);\n delete moduleExports[name];\n }\n }\n var applyRelocs = moduleExports[\"__wasm_apply_data_relocs\"];\n if (applyRelocs) {\n if (runtimeInitialized) {\n applyRelocs();\n } else {\n __RELOC_FUNCS__.push(applyRelocs);\n }\n }\n var init = moduleExports[\"__wasm_call_ctors\"];\n if (init) {\n if (runtimeInitialized) {\n init();\n } else {\n addOnPostCtor(init);\n }\n }\n return moduleExports;\n }\n __name(postInstantiation, \"postInstantiation\");\n if (flags.loadAsync) {\n if (binary instanceof WebAssembly.Module) {\n var instance = new WebAssembly.Instance(binary, info);\n return Promise.resolve(postInstantiation(binary, instance));\n }\n return WebAssembly.instantiate(binary, info).then((result) => postInstantiation(result.module, result.instance));\n }\n var module = binary instanceof WebAssembly.Module ? binary : new WebAssembly.Module(binary);\n var instance = new WebAssembly.Instance(module, info);\n return postInstantiation(module, instance);\n }\n __name(loadModule, \"loadModule\");\n if (flags.loadAsync) {\n return metadata.neededDynlibs.reduce((chain, dynNeeded) => chain.then(() => loadDynamicLibrary(dynNeeded, flags, localScope)), Promise.resolve()).then(loadModule);\n }\n metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope));\n return loadModule();\n }, \"loadWebAssemblyModule\");\n var mergeLibSymbols = /* @__PURE__ */ __name((exports2, libName2) => {\n for (var [sym, exp] of Object.entries(exports2)) {\n const setImport = /* @__PURE__ */ __name((target) => {\n if (!isSymbolDefined(target)) {\n wasmImports[target] = exp;\n }\n }, \"setImport\");\n setImport(sym);\n const main_alias = \"__main_argc_argv\";\n if (sym == \"main\") {\n setImport(main_alias);\n }\n if (sym == main_alias) {\n setImport(\"main\");\n }\n }\n }, \"mergeLibSymbols\");\n var asyncLoad = /* @__PURE__ */ __name(async (url) => {\n var arrayBuffer = await readAsync(url);\n return new Uint8Array(arrayBuffer);\n }, \"asyncLoad\");\n function loadDynamicLibrary(libName2, flags2 = {\n global: true,\n nodelete: true\n }, localScope2, handle2) {\n var dso = LDSO.loadedLibsByName[libName2];\n if (dso) {\n if (!flags2.global) {\n if (localScope2) {\n Object.assign(localScope2, dso.exports);\n }\n } else if (!dso.global) {\n dso.global = true;\n mergeLibSymbols(dso.exports, libName2);\n }\n if (flags2.nodelete && dso.refcount !== Infinity) {\n dso.refcount = Infinity;\n }\n dso.refcount++;\n if (handle2) {\n LDSO.loadedLibsByHandle[handle2] = dso;\n }\n return flags2.loadAsync ? Promise.resolve(true) : true;\n }\n dso = newDSO(libName2, handle2, \"loading\");\n dso.refcount = flags2.nodelete ? Infinity : 1;\n dso.global = flags2.global;\n function loadLibData() {\n if (handle2) {\n var data = LE_HEAP_LOAD_U32((handle2 + 28 >> 2) * 4);\n var dataSize = LE_HEAP_LOAD_U32((handle2 + 32 >> 2) * 4);\n if (data && dataSize) {\n var libData = HEAP8.slice(data, data + dataSize);\n return flags2.loadAsync ? Promise.resolve(libData) : libData;\n }\n }\n var libFile = locateFile(libName2);\n if (flags2.loadAsync) {\n return asyncLoad(libFile);\n }\n if (!readBinary) {\n throw new Error(`${libFile}: file not found, and synchronous loading of external files is not available`);\n }\n return readBinary(libFile);\n }\n __name(loadLibData, \"loadLibData\");\n function getExports() {\n if (flags2.loadAsync) {\n return loadLibData().then((libData) => loadWebAssemblyModule(libData, flags2, libName2, localScope2, handle2));\n }\n return loadWebAssemblyModule(loadLibData(), flags2, libName2, localScope2, handle2);\n }\n __name(getExports, \"getExports\");\n function moduleLoaded(exports2) {\n if (dso.global) {\n mergeLibSymbols(exports2, libName2);\n } else if (localScope2) {\n Object.assign(localScope2, exports2);\n }\n dso.exports = exports2;\n }\n __name(moduleLoaded, \"moduleLoaded\");\n if (flags2.loadAsync) {\n return getExports().then((exports2) => {\n moduleLoaded(exports2);\n return true;\n });\n }\n moduleLoaded(getExports());\n return true;\n }\n __name(loadDynamicLibrary, \"loadDynamicLibrary\");\n var reportUndefinedSymbols = /* @__PURE__ */ __name(() => {\n for (var [symName, entry] of Object.entries(GOT)) {\n if (entry.value == 0) {\n var value = resolveGlobalSymbol(symName, true).sym;\n if (!value && !entry.required) {\n continue;\n }\n if (typeof value == \"function\") {\n entry.value = addFunction(value, value.sig);\n } else if (typeof value == \"number\") {\n entry.value = value;\n } else {\n throw new Error(`bad export type for '${symName}': ${typeof value}`);\n }\n }\n }\n }, \"reportUndefinedSymbols\");\n var loadDylibs = /* @__PURE__ */ __name(() => {\n if (!dynamicLibraries.length) {\n reportUndefinedSymbols();\n return;\n }\n addRunDependency(\"loadDylibs\");\n dynamicLibraries.reduce((chain, lib) => chain.then(() => loadDynamicLibrary(lib, {\n loadAsync: true,\n global: true,\n nodelete: true,\n allowUndefined: true\n })), Promise.resolve()).then(() => {\n reportUndefinedSymbols();\n removeRunDependency(\"loadDylibs\");\n });\n }, \"loadDylibs\");\n var noExitRuntime = Module[\"noExitRuntime\"] || true;\n function setValue(ptr, value, type = \"i8\") {\n if (type.endsWith(\"*\")) type = \"*\";\n switch (type) {\n case \"i1\":\n HEAP8[ptr] = value;\n break;\n case \"i8\":\n HEAP8[ptr] = value;\n break;\n case \"i16\":\n LE_HEAP_STORE_I16((ptr >> 1) * 2, value);\n break;\n case \"i32\":\n LE_HEAP_STORE_I32((ptr >> 2) * 4, value);\n break;\n case \"i64\":\n HEAP64[ptr >> 3] = BigInt(value);\n break;\n case \"float\":\n LE_HEAP_STORE_F32((ptr >> 2) * 4, value);\n break;\n case \"double\":\n LE_HEAP_STORE_F64((ptr >> 3) * 8, value);\n break;\n case \"*\":\n LE_HEAP_STORE_U32((ptr >> 2) * 4, value);\n break;\n default:\n abort(`invalid type for setValue: ${type}`);\n }\n }\n __name(setValue, \"setValue\");\n var ___memory_base = new WebAssembly.Global({\n \"value\": \"i32\",\n \"mutable\": false\n }, 1024);\n var ___stack_pointer = new WebAssembly.Global({\n \"value\": \"i32\",\n \"mutable\": true\n }, 78224);\n var ___table_base = new WebAssembly.Global({\n \"value\": \"i32\",\n \"mutable\": false\n }, 1);\n var __abort_js = /* @__PURE__ */ __name(() => abort(\"\"), \"__abort_js\");\n __abort_js.sig = \"v\";\n var _emscripten_get_now = /* @__PURE__ */ __name(() => performance.now(), \"_emscripten_get_now\");\n _emscripten_get_now.sig = \"d\";\n var _emscripten_date_now = /* @__PURE__ */ __name(() => Date.now(), \"_emscripten_date_now\");\n _emscripten_date_now.sig = \"d\";\n var nowIsMonotonic = 1;\n var checkWasiClock = /* @__PURE__ */ __name((clock_id) => clock_id >= 0 && clock_id <= 3, \"checkWasiClock\");\n var INT53_MAX = 9007199254740992;\n var INT53_MIN = -9007199254740992;\n var bigintToI53Checked = /* @__PURE__ */ __name((num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num), \"bigintToI53Checked\");\n function _clock_time_get(clk_id, ignored_precision, ptime) {\n ignored_precision = bigintToI53Checked(ignored_precision);\n if (!checkWasiClock(clk_id)) {\n return 28;\n }\n var now;\n if (clk_id === 0) {\n now = _emscripten_date_now();\n } else if (nowIsMonotonic) {\n now = _emscripten_get_now();\n } else {\n return 52;\n }\n var nsec = Math.round(now * 1e3 * 1e3);\n HEAP64[ptime >> 3] = BigInt(nsec);\n return 0;\n }\n __name(_clock_time_get, \"_clock_time_get\");\n _clock_time_get.sig = \"iijp\";\n var getHeapMax = /* @__PURE__ */ __name(() => (\n // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate\n // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side\n // for any code that deals with heap sizes, which would require special\n // casing all heap size related code to treat 0 specially.\n 2147483648\n ), \"getHeapMax\");\n var growMemory = /* @__PURE__ */ __name((size) => {\n var b = wasmMemory.buffer;\n var pages = (size - b.byteLength + 65535) / 65536 | 0;\n try {\n wasmMemory.grow(pages);\n updateMemoryViews();\n return 1;\n } catch (e) {\n }\n }, \"growMemory\");\n var _emscripten_resize_heap = /* @__PURE__ */ __name((requestedSize) => {\n var oldSize = HEAPU8.length;\n requestedSize >>>= 0;\n var maxHeapSize = getHeapMax();\n if (requestedSize > maxHeapSize) {\n return false;\n }\n for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {\n var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);\n overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);\n var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));\n var replacement = growMemory(newSize);\n if (replacement) {\n return true;\n }\n }\n return false;\n }, \"_emscripten_resize_heap\");\n _emscripten_resize_heap.sig = \"ip\";\n var _fd_close = /* @__PURE__ */ __name((fd) => 52, \"_fd_close\");\n _fd_close.sig = \"ii\";\n function _fd_seek(fd, offset, whence, newOffset) {\n offset = bigintToI53Checked(offset);\n return 70;\n }\n __name(_fd_seek, \"_fd_seek\");\n _fd_seek.sig = \"iijip\";\n var printCharBuffers = [null, [], []];\n var printChar = /* @__PURE__ */ __name((stream, curr) => {\n var buffer = printCharBuffers[stream];\n if (curr === 0 || curr === 10) {\n (stream === 1 ? out : err)(UTF8ArrayToString(buffer));\n buffer.length = 0;\n } else {\n buffer.push(curr);\n }\n }, \"printChar\");\n var flush_NO_FILESYSTEM = /* @__PURE__ */ __name(() => {\n if (printCharBuffers[1].length) printChar(1, 10);\n if (printCharBuffers[2].length) printChar(2, 10);\n }, \"flush_NO_FILESYSTEM\");\n var SYSCALLS = {\n varargs: void 0,\n getStr(ptr) {\n var ret = UTF8ToString(ptr);\n return ret;\n }\n };\n var _fd_write = /* @__PURE__ */ __name((fd, iov, iovcnt, pnum) => {\n var num = 0;\n for (var i2 = 0; i2 < iovcnt; i2++) {\n var ptr = LE_HEAP_LOAD_U32((iov >> 2) * 4);\n var len = LE_HEAP_LOAD_U32((iov + 4 >> 2) * 4);\n iov += 8;\n for (var j = 0; j < len; j++) {\n printChar(fd, HEAPU8[ptr + j]);\n }\n num += len;\n }\n LE_HEAP_STORE_U32((pnum >> 2) * 4, num);\n return 0;\n }, \"_fd_write\");\n _fd_write.sig = \"iippp\";\n function _tree_sitter_log_callback(isLexMessage, messageAddress) {\n if (Module.currentLogCallback) {\n const message = UTF8ToString(messageAddress);\n Module.currentLogCallback(message, isLexMessage !== 0);\n }\n }\n __name(_tree_sitter_log_callback, \"_tree_sitter_log_callback\");\n function _tree_sitter_parse_callback(inputBufferAddress, index, row, column, lengthAddress) {\n const INPUT_BUFFER_SIZE = 10 * 1024;\n const string = Module.currentParseCallback(index, {\n row,\n column\n });\n if (typeof string === \"string\") {\n setValue(lengthAddress, string.length, \"i32\");\n stringToUTF16(string, inputBufferAddress, INPUT_BUFFER_SIZE);\n } else {\n setValue(lengthAddress, 0, \"i32\");\n }\n }\n __name(_tree_sitter_parse_callback, \"_tree_sitter_parse_callback\");\n function _tree_sitter_progress_callback(currentOffset, hasError) {\n if (Module.currentProgressCallback) {\n return Module.currentProgressCallback({\n currentOffset,\n hasError\n });\n }\n return false;\n }\n __name(_tree_sitter_progress_callback, \"_tree_sitter_progress_callback\");\n function _tree_sitter_query_progress_callback(currentOffset) {\n if (Module.currentQueryProgressCallback) {\n return Module.currentQueryProgressCallback({\n currentOffset\n });\n }\n return false;\n }\n __name(_tree_sitter_query_progress_callback, \"_tree_sitter_query_progress_callback\");\n var runtimeKeepaliveCounter = 0;\n var keepRuntimeAlive = /* @__PURE__ */ __name(() => noExitRuntime || runtimeKeepaliveCounter > 0, \"keepRuntimeAlive\");\n var _proc_exit = /* @__PURE__ */ __name((code) => {\n EXITSTATUS = code;\n if (!keepRuntimeAlive()) {\n Module[\"onExit\"]?.(code);\n ABORT = true;\n }\n quit_(code, new ExitStatus(code));\n }, \"_proc_exit\");\n _proc_exit.sig = \"vi\";\n var exitJS = /* @__PURE__ */ __name((status, implicit) => {\n EXITSTATUS = status;\n _proc_exit(status);\n }, \"exitJS\");\n var handleException = /* @__PURE__ */ __name((e) => {\n if (e instanceof ExitStatus || e == \"unwind\") {\n return EXITSTATUS;\n }\n quit_(1, e);\n }, \"handleException\");\n var lengthBytesUTF8 = /* @__PURE__ */ __name((str) => {\n var len = 0;\n for (var i2 = 0; i2 < str.length; ++i2) {\n var c = str.charCodeAt(i2);\n if (c <= 127) {\n len++;\n } else if (c <= 2047) {\n len += 2;\n } else if (c >= 55296 && c <= 57343) {\n len += 4;\n ++i2;\n } else {\n len += 3;\n }\n }\n return len;\n }, \"lengthBytesUTF8\");\n var stringToUTF8Array = /* @__PURE__ */ __name((str, heap, outIdx, maxBytesToWrite) => {\n if (!(maxBytesToWrite > 0)) return 0;\n var startIdx = outIdx;\n var endIdx = outIdx + maxBytesToWrite - 1;\n for (var i2 = 0; i2 < str.length; ++i2) {\n var u = str.charCodeAt(i2);\n if (u >= 55296 && u <= 57343) {\n var u1 = str.charCodeAt(++i2);\n u = 65536 + ((u & 1023) << 10) | u1 & 1023;\n }\n if (u <= 127) {\n if (outIdx >= endIdx) break;\n heap[outIdx++] = u;\n } else if (u <= 2047) {\n if (outIdx + 1 >= endIdx) break;\n heap[outIdx++] = 192 | u >> 6;\n heap[outIdx++] = 128 | u & 63;\n } else if (u <= 65535) {\n if (outIdx + 2 >= endIdx) break;\n heap[outIdx++] = 224 | u >> 12;\n heap[outIdx++] = 128 | u >> 6 & 63;\n heap[outIdx++] = 128 | u & 63;\n } else {\n if (outIdx + 3 >= endIdx) break;\n heap[outIdx++] = 240 | u >> 18;\n heap[outIdx++] = 128 | u >> 12 & 63;\n heap[outIdx++] = 128 | u >> 6 & 63;\n heap[outIdx++] = 128 | u & 63;\n }\n }\n heap[outIdx] = 0;\n return outIdx - startIdx;\n }, \"stringToUTF8Array\");\n var stringToUTF8 = /* @__PURE__ */ __name((str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite), \"stringToUTF8\");\n var stackAlloc = /* @__PURE__ */ __name((sz) => __emscripten_stack_alloc(sz), \"stackAlloc\");\n var stringToUTF8OnStack = /* @__PURE__ */ __name((str) => {\n var size = lengthBytesUTF8(str) + 1;\n var ret = stackAlloc(size);\n stringToUTF8(str, ret, size);\n return ret;\n }, \"stringToUTF8OnStack\");\n var AsciiToString = /* @__PURE__ */ __name((ptr) => {\n var str = \"\";\n while (1) {\n var ch = HEAPU8[ptr++];\n if (!ch) return str;\n str += String.fromCharCode(ch);\n }\n }, \"AsciiToString\");\n var stringToUTF16 = /* @__PURE__ */ __name((str, outPtr, maxBytesToWrite) => {\n maxBytesToWrite ??= 2147483647;\n if (maxBytesToWrite < 2) return 0;\n maxBytesToWrite -= 2;\n var startPtr = outPtr;\n var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;\n for (var i2 = 0; i2 < numCharsToWrite; ++i2) {\n var codeUnit = str.charCodeAt(i2);\n LE_HEAP_STORE_I16((outPtr >> 1) * 2, codeUnit);\n outPtr += 2;\n }\n LE_HEAP_STORE_I16((outPtr >> 1) * 2, 0);\n return outPtr - startPtr;\n }, \"stringToUTF16\");\n var wasmImports = {\n /** @export */\n __heap_base: ___heap_base,\n /** @export */\n __indirect_function_table: wasmTable,\n /** @export */\n __memory_base: ___memory_base,\n /** @export */\n __stack_pointer: ___stack_pointer,\n /** @export */\n __table_base: ___table_base,\n /** @export */\n _abort_js: __abort_js,\n /** @export */\n clock_time_get: _clock_time_get,\n /** @export */\n emscripten_resize_heap: _emscripten_resize_heap,\n /** @export */\n fd_close: _fd_close,\n /** @export */\n fd_seek: _fd_seek,\n /** @export */\n fd_write: _fd_write,\n /** @export */\n memory: wasmMemory,\n /** @export */\n tree_sitter_log_callback: _tree_sitter_log_callback,\n /** @export */\n tree_sitter_parse_callback: _tree_sitter_parse_callback,\n /** @export */\n tree_sitter_progress_callback: _tree_sitter_progress_callback,\n /** @export */\n tree_sitter_query_progress_callback: _tree_sitter_query_progress_callback\n };\n var wasmExports = await createWasm();\n var ___wasm_call_ctors = wasmExports[\"__wasm_call_ctors\"];\n var _malloc = Module[\"_malloc\"] = wasmExports[\"malloc\"];\n var _calloc = Module[\"_calloc\"] = wasmExports[\"calloc\"];\n var _realloc = Module[\"_realloc\"] = wasmExports[\"realloc\"];\n var _free = Module[\"_free\"] = wasmExports[\"free\"];\n var _memcmp = Module[\"_memcmp\"] = wasmExports[\"memcmp\"];\n var _ts_language_symbol_count = Module[\"_ts_language_symbol_count\"] = wasmExports[\"ts_language_symbol_count\"];\n var _ts_language_state_count = Module[\"_ts_language_state_count\"] = wasmExports[\"ts_language_state_count\"];\n var _ts_language_version = Module[\"_ts_language_version\"] = wasmExports[\"ts_language_version\"];\n var _ts_language_abi_version = Module[\"_ts_language_abi_version\"] = wasmExports[\"ts_language_abi_version\"];\n var _ts_language_metadata = Module[\"_ts_language_metadata\"] = wasmExports[\"ts_language_metadata\"];\n var _ts_language_name = Module[\"_ts_language_name\"] = wasmExports[\"ts_language_name\"];\n var _ts_language_field_count = Module[\"_ts_language_field_count\"] = wasmExports[\"ts_language_field_count\"];\n var _ts_language_next_state = Module[\"_ts_language_next_state\"] = wasmExports[\"ts_language_next_state\"];\n var _ts_language_symbol_name = Module[\"_ts_language_symbol_name\"] = wasmExports[\"ts_language_symbol_name\"];\n var _ts_language_symbol_for_name = Module[\"_ts_language_symbol_for_name\"] = wasmExports[\"ts_language_symbol_for_name\"];\n var _strncmp = Module[\"_strncmp\"] = wasmExports[\"strncmp\"];\n var _ts_language_symbol_type = Module[\"_ts_language_symbol_type\"] = wasmExports[\"ts_language_symbol_type\"];\n var _ts_language_field_name_for_id = Module[\"_ts_language_field_name_for_id\"] = wasmExports[\"ts_language_field_name_for_id\"];\n var _ts_lookahead_iterator_new = Module[\"_ts_lookahead_iterator_new\"] = wasmExports[\"ts_lookahead_iterator_new\"];\n var _ts_lookahead_iterator_delete = Module[\"_ts_lookahead_iterator_delete\"] = wasmExports[\"ts_lookahead_iterator_delete\"];\n var _ts_lookahead_iterator_reset_state = Module[\"_ts_lookahead_iterator_reset_state\"] = wasmExports[\"ts_lookahead_iterator_reset_state\"];\n var _ts_lookahead_iterator_reset = Module[\"_ts_lookahead_iterator_reset\"] = wasmExports[\"ts_lookahead_iterator_reset\"];\n var _ts_lookahead_iterator_next = Module[\"_ts_lookahead_iterator_next\"] = wasmExports[\"ts_lookahead_iterator_next\"];\n var _ts_lookahead_iterator_current_symbol = Module[\"_ts_lookahead_iterator_current_symbol\"] = wasmExports[\"ts_lookahead_iterator_current_symbol\"];\n var _ts_parser_delete = Module[\"_ts_parser_delete\"] = wasmExports[\"ts_parser_delete\"];\n var _ts_parser_reset = Module[\"_ts_parser_reset\"] = wasmExports[\"ts_parser_reset\"];\n var _ts_parser_set_language = Module[\"_ts_parser_set_language\"] = wasmExports[\"ts_parser_set_language\"];\n var _ts_parser_timeout_micros = Module[\"_ts_parser_timeout_micros\"] = wasmExports[\"ts_parser_timeout_micros\"];\n var _ts_parser_set_timeout_micros = Module[\"_ts_parser_set_timeout_micros\"] = wasmExports[\"ts_parser_set_timeout_micros\"];\n var _ts_parser_set_included_ranges = Module[\"_ts_parser_set_included_ranges\"] = wasmExports[\"ts_parser_set_included_ranges\"];\n var _ts_query_new = Module[\"_ts_query_new\"] = wasmExports[\"ts_query_new\"];\n var _ts_query_delete = Module[\"_ts_query_delete\"] = wasmExports[\"ts_query_delete\"];\n var _iswspace = Module[\"_iswspace\"] = wasmExports[\"iswspace\"];\n var _iswalnum = Module[\"_iswalnum\"] = wasmExports[\"iswalnum\"];\n var _ts_query_pattern_count = Module[\"_ts_query_pattern_count\"] = wasmExports[\"ts_query_pattern_count\"];\n var _ts_query_capture_count = Module[\"_ts_query_capture_count\"] = wasmExports[\"ts_query_capture_count\"];\n var _ts_query_string_count = Module[\"_ts_query_string_count\"] = wasmExports[\"ts_query_string_count\"];\n var _ts_query_capture_name_for_id = Module[\"_ts_query_capture_name_for_id\"] = wasmExports[\"ts_query_capture_name_for_id\"];\n var _ts_query_capture_quantifier_for_id = Module[\"_ts_query_capture_quantifier_for_id\"] = wasmExports[\"ts_query_capture_quantifier_for_id\"];\n var _ts_query_string_value_for_id = Module[\"_ts_query_string_value_for_id\"] = wasmExports[\"ts_query_string_value_for_id\"];\n var _ts_query_predicates_for_pattern = Module[\"_ts_query_predicates_for_pattern\"] = wasmExports[\"ts_query_predicates_for_pattern\"];\n var _ts_query_start_byte_for_pattern = Module[\"_ts_query_start_byte_for_pattern\"] = wasmExports[\"ts_query_start_byte_for_pattern\"];\n var _ts_query_end_byte_for_pattern = Module[\"_ts_query_end_byte_for_pattern\"] = wasmExports[\"ts_query_end_byte_for_pattern\"];\n var _ts_query_is_pattern_rooted = Module[\"_ts_query_is_pattern_rooted\"] = wasmExports[\"ts_query_is_pattern_rooted\"];\n var _ts_query_is_pattern_non_local = Module[\"_ts_query_is_pattern_non_local\"] = wasmExports[\"ts_query_is_pattern_non_local\"];\n var _ts_query_is_pattern_guaranteed_at_step = Module[\"_ts_query_is_pattern_guaranteed_at_step\"] = wasmExports[\"ts_query_is_pattern_guaranteed_at_step\"];\n var _ts_query_disable_capture = Module[\"_ts_query_disable_capture\"] = wasmExports[\"ts_query_disable_capture\"];\n var _ts_query_disable_pattern = Module[\"_ts_query_disable_pattern\"] = wasmExports[\"ts_query_disable_pattern\"];\n var _ts_tree_copy = Module[\"_ts_tree_copy\"] = wasmExports[\"ts_tree_copy\"];\n var _ts_tree_delete = Module[\"_ts_tree_delete\"] = wasmExports[\"ts_tree_delete\"];\n var _ts_init = Module[\"_ts_init\"] = wasmExports[\"ts_init\"];\n var _ts_parser_new_wasm = Module[\"_ts_parser_new_wasm\"] = wasmExports[\"ts_parser_new_wasm\"];\n var _ts_parser_enable_logger_wasm = Module[\"_ts_parser_enable_logger_wasm\"] = wasmExports[\"ts_parser_enable_logger_wasm\"];\n var _ts_parser_parse_wasm = Module[\"_ts_parser_parse_wasm\"] = wasmExports[\"ts_parser_parse_wasm\"];\n var _ts_parser_included_ranges_wasm = Module[\"_ts_parser_included_ranges_wasm\"] = wasmExports[\"ts_parser_included_ranges_wasm\"];\n var _ts_language_type_is_named_wasm = Module[\"_ts_language_type_is_named_wasm\"] = wasmExports[\"ts_language_type_is_named_wasm\"];\n var _ts_language_type_is_visible_wasm = Module[\"_ts_language_type_is_visible_wasm\"] = wasmExports[\"ts_language_type_is_visible_wasm\"];\n var _ts_language_supertypes_wasm = Module[\"_ts_language_supertypes_wasm\"] = wasmExports[\"ts_language_supertypes_wasm\"];\n var _ts_language_subtypes_wasm = Module[\"_ts_language_subtypes_wasm\"] = wasmExports[\"ts_language_subtypes_wasm\"];\n var _ts_tree_root_node_wasm = Module[\"_ts_tree_root_node_wasm\"] = wasmExports[\"ts_tree_root_node_wasm\"];\n var _ts_tree_root_node_with_offset_wasm = Module[\"_ts_tree_root_node_with_offset_wasm\"] = wasmExports[\"ts_tree_root_node_with_offset_wasm\"];\n var _ts_tree_edit_wasm = Module[\"_ts_tree_edit_wasm\"] = wasmExports[\"ts_tree_edit_wasm\"];\n var _ts_tree_included_ranges_wasm = Module[\"_ts_tree_included_ranges_wasm\"] = wasmExports[\"ts_tree_included_ranges_wasm\"];\n var _ts_tree_get_changed_ranges_wasm = Module[\"_ts_tree_get_changed_ranges_wasm\"] = wasmExports[\"ts_tree_get_changed_ranges_wasm\"];\n var _ts_tree_cursor_new_wasm = Module[\"_ts_tree_cursor_new_wasm\"] = wasmExports[\"ts_tree_cursor_new_wasm\"];\n var _ts_tree_cursor_copy_wasm = Module[\"_ts_tree_cursor_copy_wasm\"] = wasmExports[\"ts_tree_cursor_copy_wasm\"];\n var _ts_tree_cursor_delete_wasm = Module[\"_ts_tree_cursor_delete_wasm\"] = wasmExports[\"ts_tree_cursor_delete_wasm\"];\n var _ts_tree_cursor_reset_wasm = Module[\"_ts_tree_cursor_reset_wasm\"] = wasmExports[\"ts_tree_cursor_reset_wasm\"];\n var _ts_tree_cursor_reset_to_wasm = Module[\"_ts_tree_cursor_reset_to_wasm\"] = wasmExports[\"ts_tree_cursor_reset_to_wasm\"];\n var _ts_tree_cursor_goto_first_child_wasm = Module[\"_ts_tree_cursor_goto_first_child_wasm\"] = wasmExports[\"ts_tree_cursor_goto_first_child_wasm\"];\n var _ts_tree_cursor_goto_last_child_wasm = Module[\"_ts_tree_cursor_goto_last_child_wasm\"] = wasmExports[\"ts_tree_cursor_goto_last_child_wasm\"];\n var _ts_tree_cursor_goto_first_child_for_index_wasm = Module[\"_ts_tree_cursor_goto_first_child_for_index_wasm\"] = wasmExports[\"ts_tree_cursor_goto_first_child_for_index_wasm\"];\n var _ts_tree_cursor_goto_first_child_for_position_wasm = Module[\"_ts_tree_cursor_goto_first_child_for_position_wasm\"] = wasmExports[\"ts_tree_cursor_goto_first_child_for_position_wasm\"];\n var _ts_tree_cursor_goto_next_sibling_wasm = Module[\"_ts_tree_cursor_goto_next_sibling_wasm\"] = wasmExports[\"ts_tree_cursor_goto_next_sibling_wasm\"];\n var _ts_tree_cursor_goto_previous_sibling_wasm = Module[\"_ts_tree_cursor_goto_previous_sibling_wasm\"] = wasmExports[\"ts_tree_cursor_goto_previous_sibling_wasm\"];\n var _ts_tree_cursor_goto_descendant_wasm = Module[\"_ts_tree_cursor_goto_descendant_wasm\"] = wasmExports[\"ts_tree_cursor_goto_descendant_wasm\"];\n var _ts_tree_cursor_goto_parent_wasm = Module[\"_ts_tree_cursor_goto_parent_wasm\"] = wasmExports[\"ts_tree_cursor_goto_parent_wasm\"];\n var _ts_tree_cursor_current_node_type_id_wasm = Module[\"_ts_tree_cursor_current_node_type_id_wasm\"] = wasmExports[\"ts_tree_cursor_current_node_type_id_wasm\"];\n var _ts_tree_cursor_current_node_state_id_wasm = Module[\"_ts_tree_cursor_current_node_state_id_wasm\"] = wasmExports[\"ts_tree_cursor_current_node_state_id_wasm\"];\n var _ts_tree_cursor_current_node_is_named_wasm = Module[\"_ts_tree_cursor_current_node_is_named_wasm\"] = wasmExports[\"ts_tree_cursor_current_node_is_named_wasm\"];\n var _ts_tree_cursor_current_node_is_missing_wasm = Module[\"_ts_tree_cursor_current_node_is_missing_wasm\"] = wasmExports[\"ts_tree_cursor_current_node_is_missing_wasm\"];\n var _ts_tree_cursor_current_node_id_wasm = Module[\"_ts_tree_cursor_current_node_id_wasm\"] = wasmExports[\"ts_tree_cursor_current_node_id_wasm\"];\n var _ts_tree_cursor_start_position_wasm = Module[\"_ts_tree_cursor_start_position_wasm\"] = wasmExports[\"ts_tree_cursor_start_position_wasm\"];\n var _ts_tree_cursor_end_position_wasm = Module[\"_ts_tree_cursor_end_position_wasm\"] = wasmExports[\"ts_tree_cursor_end_position_wasm\"];\n var _ts_tree_cursor_start_index_wasm = Module[\"_ts_tree_cursor_start_index_wasm\"] = wasmExports[\"ts_tree_cursor_start_index_wasm\"];\n var _ts_tree_cursor_end_index_wasm = Module[\"_ts_tree_cursor_end_index_wasm\"] = wasmExports[\"ts_tree_cursor_end_index_wasm\"];\n var _ts_tree_cursor_current_field_id_wasm = Module[\"_ts_tree_cursor_current_field_id_wasm\"] = wasmExports[\"ts_tree_cursor_current_field_id_wasm\"];\n var _ts_tree_cursor_current_depth_wasm = Module[\"_ts_tree_cursor_current_depth_wasm\"] = wasmExports[\"ts_tree_cursor_current_depth_wasm\"];\n var _ts_tree_cursor_current_descendant_index_wasm = Module[\"_ts_tree_cursor_current_descendant_index_wasm\"] = wasmExports[\"ts_tree_cursor_current_descendant_index_wasm\"];\n var _ts_tree_cursor_current_node_wasm = Module[\"_ts_tree_cursor_current_node_wasm\"] = wasmExports[\"ts_tree_cursor_current_node_wasm\"];\n var _ts_node_symbol_wasm = Module[\"_ts_node_symbol_wasm\"] = wasmExports[\"ts_node_symbol_wasm\"];\n var _ts_node_field_name_for_child_wasm = Module[\"_ts_node_field_name_for_child_wasm\"] = wasmExports[\"ts_node_field_name_for_child_wasm\"];\n var _ts_node_field_name_for_named_child_wasm = Module[\"_ts_node_field_name_for_named_child_wasm\"] = wasmExports[\"ts_node_field_name_for_named_child_wasm\"];\n var _ts_node_children_by_field_id_wasm = Module[\"_ts_node_children_by_field_id_wasm\"] = wasmExports[\"ts_node_children_by_field_id_wasm\"];\n var _ts_node_first_child_for_byte_wasm = Module[\"_ts_node_first_child_for_byte_wasm\"] = wasmExports[\"ts_node_first_child_for_byte_wasm\"];\n var _ts_node_first_named_child_for_byte_wasm = Module[\"_ts_node_first_named_child_for_byte_wasm\"] = wasmExports[\"ts_node_first_named_child_for_byte_wasm\"];\n var _ts_node_grammar_symbol_wasm = Module[\"_ts_node_grammar_symbol_wasm\"] = wasmExports[\"ts_node_grammar_symbol_wasm\"];\n var _ts_node_child_count_wasm = Module[\"_ts_node_child_count_wasm\"] = wasmExports[\"ts_node_child_count_wasm\"];\n var _ts_node_named_child_count_wasm = Module[\"_ts_node_named_child_count_wasm\"] = wasmExports[\"ts_node_named_child_count_wasm\"];\n var _ts_node_child_wasm = Module[\"_ts_node_child_wasm\"] = wasmExports[\"ts_node_child_wasm\"];\n var _ts_node_named_child_wasm = Module[\"_ts_node_named_child_wasm\"] = wasmExports[\"ts_node_named_child_wasm\"];\n var _ts_node_child_by_field_id_wasm = Module[\"_ts_node_child_by_field_id_wasm\"] = wasmExports[\"ts_node_child_by_field_id_wasm\"];\n var _ts_node_next_sibling_wasm = Module[\"_ts_node_next_sibling_wasm\"] = wasmExports[\"ts_node_next_sibling_wasm\"];\n var _ts_node_prev_sibling_wasm = Module[\"_ts_node_prev_sibling_wasm\"] = wasmExports[\"ts_node_prev_sibling_wasm\"];\n var _ts_node_next_named_sibling_wasm = Module[\"_ts_node_next_named_sibling_wasm\"] = wasmExports[\"ts_node_next_named_sibling_wasm\"];\n var _ts_node_prev_named_sibling_wasm = Module[\"_ts_node_prev_named_sibling_wasm\"] = wasmExports[\"ts_node_prev_named_sibling_wasm\"];\n var _ts_node_descendant_count_wasm = Module[\"_ts_node_descendant_count_wasm\"] = wasmExports[\"ts_node_descendant_count_wasm\"];\n var _ts_node_parent_wasm = Module[\"_ts_node_parent_wasm\"] = wasmExports[\"ts_node_parent_wasm\"];\n var _ts_node_child_with_descendant_wasm = Module[\"_ts_node_child_with_descendant_wasm\"] = wasmExports[\"ts_node_child_with_descendant_wasm\"];\n var _ts_node_descendant_for_index_wasm = Module[\"_ts_node_descendant_for_index_wasm\"] = wasmExports[\"ts_node_descendant_for_index_wasm\"];\n var _ts_node_named_descendant_for_index_wasm = Module[\"_ts_node_named_descendant_for_index_wasm\"] = wasmExports[\"ts_node_named_descendant_for_index_wasm\"];\n var _ts_node_descendant_for_position_wasm = Module[\"_ts_node_descendant_for_position_wasm\"] = wasmExports[\"ts_node_descendant_for_position_wasm\"];\n var _ts_node_named_descendant_for_position_wasm = Module[\"_ts_node_named_descendant_for_position_wasm\"] = wasmExports[\"ts_node_named_descendant_for_position_wasm\"];\n var _ts_node_start_point_wasm = Module[\"_ts_node_start_point_wasm\"] = wasmExports[\"ts_node_start_point_wasm\"];\n var _ts_node_end_point_wasm = Module[\"_ts_node_end_point_wasm\"] = wasmExports[\"ts_node_end_point_wasm\"];\n var _ts_node_start_index_wasm = Module[\"_ts_node_start_index_wasm\"] = wasmExports[\"ts_node_start_index_wasm\"];\n var _ts_node_end_index_wasm = Module[\"_ts_node_end_index_wasm\"] = wasmExports[\"ts_node_end_index_wasm\"];\n var _ts_node_to_string_wasm = Module[\"_ts_node_to_string_wasm\"] = wasmExports[\"ts_node_to_string_wasm\"];\n var _ts_node_children_wasm = Module[\"_ts_node_children_wasm\"] = wasmExports[\"ts_node_children_wasm\"];\n var _ts_node_named_children_wasm = Module[\"_ts_node_named_children_wasm\"] = wasmExports[\"ts_node_named_children_wasm\"];\n var _ts_node_descendants_of_type_wasm = Module[\"_ts_node_descendants_of_type_wasm\"] = wasmExports[\"ts_node_descendants_of_type_wasm\"];\n var _ts_node_is_named_wasm = Module[\"_ts_node_is_named_wasm\"] = wasmExports[\"ts_node_is_named_wasm\"];\n var _ts_node_has_changes_wasm = Module[\"_ts_node_has_changes_wasm\"] = wasmExports[\"ts_node_has_changes_wasm\"];\n var _ts_node_has_error_wasm = Module[\"_ts_node_has_error_wasm\"] = wasmExports[\"ts_node_has_error_wasm\"];\n var _ts_node_is_error_wasm = Module[\"_ts_node_is_error_wasm\"] = wasmExports[\"ts_node_is_error_wasm\"];\n var _ts_node_is_missing_wasm = Module[\"_ts_node_is_missing_wasm\"] = wasmExports[\"ts_node_is_missing_wasm\"];\n var _ts_node_is_extra_wasm = Module[\"_ts_node_is_extra_wasm\"] = wasmExports[\"ts_node_is_extra_wasm\"];\n var _ts_node_parse_state_wasm = Module[\"_ts_node_parse_state_wasm\"] = wasmExports[\"ts_node_parse_state_wasm\"];\n var _ts_node_next_parse_state_wasm = Module[\"_ts_node_next_parse_state_wasm\"] = wasmExports[\"ts_node_next_parse_state_wasm\"];\n var _ts_query_matches_wasm = Module[\"_ts_query_matches_wasm\"] = wasmExports[\"ts_query_matches_wasm\"];\n var _ts_query_captures_wasm = Module[\"_ts_query_captures_wasm\"] = wasmExports[\"ts_query_captures_wasm\"];\n var _memset = Module[\"_memset\"] = wasmExports[\"memset\"];\n var _memcpy = Module[\"_memcpy\"] = wasmExports[\"memcpy\"];\n var _memmove = Module[\"_memmove\"] = wasmExports[\"memmove\"];\n var _iswalpha = Module[\"_iswalpha\"] = wasmExports[\"iswalpha\"];\n var _iswblank = Module[\"_iswblank\"] = wasmExports[\"iswblank\"];\n var _iswdigit = Module[\"_iswdigit\"] = wasmExports[\"iswdigit\"];\n var _iswlower = Module[\"_iswlower\"] = wasmExports[\"iswlower\"];\n var _iswupper = Module[\"_iswupper\"] = wasmExports[\"iswupper\"];\n var _iswxdigit = Module[\"_iswxdigit\"] = wasmExports[\"iswxdigit\"];\n var _memchr = Module[\"_memchr\"] = wasmExports[\"memchr\"];\n var _strlen = Module[\"_strlen\"] = wasmExports[\"strlen\"];\n var _strcmp = Module[\"_strcmp\"] = wasmExports[\"strcmp\"];\n var _strncat = Module[\"_strncat\"] = wasmExports[\"strncat\"];\n var _strncpy = Module[\"_strncpy\"] = wasmExports[\"strncpy\"];\n var _towlower = Module[\"_towlower\"] = wasmExports[\"towlower\"];\n var _towupper = Module[\"_towupper\"] = wasmExports[\"towupper\"];\n var _setThrew = wasmExports[\"setThrew\"];\n var __emscripten_stack_restore = wasmExports[\"_emscripten_stack_restore\"];\n var __emscripten_stack_alloc = wasmExports[\"_emscripten_stack_alloc\"];\n var _emscripten_stack_get_current = wasmExports[\"emscripten_stack_get_current\"];\n var ___wasm_apply_data_relocs = wasmExports[\"__wasm_apply_data_relocs\"];\n Module[\"setValue\"] = setValue;\n Module[\"getValue\"] = getValue;\n Module[\"UTF8ToString\"] = UTF8ToString;\n Module[\"stringToUTF8\"] = stringToUTF8;\n Module[\"lengthBytesUTF8\"] = lengthBytesUTF8;\n Module[\"AsciiToString\"] = AsciiToString;\n Module[\"stringToUTF16\"] = stringToUTF16;\n Module[\"loadWebAssemblyModule\"] = loadWebAssemblyModule;\n function callMain(args2 = []) {\n var entryFunction = resolveGlobalSymbol(\"main\").sym;\n if (!entryFunction) return;\n args2.unshift(thisProgram);\n var argc = args2.length;\n var argv = stackAlloc((argc + 1) * 4);\n var argv_ptr = argv;\n args2.forEach((arg) => {\n LE_HEAP_STORE_U32((argv_ptr >> 2) * 4, stringToUTF8OnStack(arg));\n argv_ptr += 4;\n });\n LE_HEAP_STORE_U32((argv_ptr >> 2) * 4, 0);\n try {\n var ret = entryFunction(argc, argv);\n exitJS(\n ret,\n /* implicit = */\n true\n );\n return ret;\n } catch (e) {\n return handleException(e);\n }\n }\n __name(callMain, \"callMain\");\n function run(args2 = arguments_) {\n if (runDependencies > 0) {\n dependenciesFulfilled = run;\n return;\n }\n preRun();\n if (runDependencies > 0) {\n dependenciesFulfilled = run;\n return;\n }\n function doRun() {\n Module[\"calledRun\"] = true;\n if (ABORT) return;\n initRuntime();\n preMain();\n readyPromiseResolve(Module);\n Module[\"onRuntimeInitialized\"]?.();\n var noInitialRun = Module[\"noInitialRun\"];\n if (!noInitialRun) callMain(args2);\n postRun();\n }\n __name(doRun, \"doRun\");\n if (Module[\"setStatus\"]) {\n Module[\"setStatus\"](\"Running...\");\n setTimeout(() => {\n setTimeout(() => Module[\"setStatus\"](\"\"), 1);\n doRun();\n }, 1);\n } else {\n doRun();\n }\n }\n __name(run, \"run\");\n if (Module[\"preInit\"]) {\n if (typeof Module[\"preInit\"] == \"function\") Module[\"preInit\"] = [Module[\"preInit\"]];\n while (Module[\"preInit\"].length > 0) {\n Module[\"preInit\"].pop()();\n }\n }\n run();\n moduleRtn = readyPromise;\n return moduleRtn;\n };\n })();\n if (typeof exports === \"object\" && typeof module === \"object\") {\n module.exports = Module;\n module.exports.default = Module;\n } else if (typeof define === \"function\" && define[\"amd\"])\n define([], () => Module);\n }\n});\n\n// src/index.ts\nvar index_exports = {};\n__export(index_exports, {\n CaptureQuantifier: () => CaptureQuantifier,\n LANGUAGE_VERSION: () => LANGUAGE_VERSION,\n Language: () => Language,\n LookaheadIterator: () => LookaheadIterator,\n MIN_COMPATIBLE_VERSION: () => MIN_COMPATIBLE_VERSION,\n Node: () => Node,\n Parser: () => Parser,\n Query: () => Query,\n Tree: () => Tree,\n TreeCursor: () => TreeCursor\n});\nmodule.exports = __toCommonJS(index_exports);\n\n// src/constants.ts\nvar SIZE_OF_SHORT = 2;\nvar SIZE_OF_INT = 4;\nvar SIZE_OF_CURSOR = 4 * SIZE_OF_INT;\nvar SIZE_OF_NODE = 5 * SIZE_OF_INT;\nvar SIZE_OF_POINT = 2 * SIZE_OF_INT;\nvar SIZE_OF_RANGE = 2 * SIZE_OF_INT + 2 * SIZE_OF_POINT;\nvar ZERO_POINT = { row: 0, column: 0 };\nvar INTERNAL = Symbol(\"INTERNAL\");\nfunction assertInternal(x) {\n if (x !== INTERNAL) throw new Error(\"Illegal constructor\");\n}\n__name(assertInternal, \"assertInternal\");\nfunction isPoint(point) {\n return !!point && typeof point.row === \"number\" && typeof point.column === \"number\";\n}\n__name(isPoint, \"isPoint\");\nfunction setModule(module2) {\n C = module2;\n}\n__name(setModule, \"setModule\");\nvar C;\n\n// src/lookahead_iterator.ts\nvar LookaheadIterator = class {\n static {\n __name(this, \"LookaheadIterator\");\n }\n /** @internal */\n [0] = 0;\n // Internal handle for WASM\n /** @internal */\n language;\n /** @internal */\n constructor(internal, address, language) {\n assertInternal(internal);\n this[0] = address;\n this.language = language;\n }\n /** Get the current symbol of the lookahead iterator. */\n get currentTypeId() {\n return C._ts_lookahead_iterator_current_symbol(this[0]);\n }\n /** Get the current symbol name of the lookahead iterator. */\n get currentType() {\n return this.language.types[this.currentTypeId] || \"ERROR\";\n }\n /** Delete the lookahead iterator, freeing its resources. */\n delete() {\n C._ts_lookahead_iterator_delete(this[0]);\n this[0] = 0;\n }\n /**\n * Reset the lookahead iterator.\n *\n * This returns `true` if the language was set successfully and `false`\n * otherwise.\n */\n reset(language, stateId) {\n if (C._ts_lookahead_iterator_reset(this[0], language[0], stateId)) {\n this.language = language;\n return true;\n }\n return false;\n }\n /**\n * Reset the lookahead iterator to another state.\n *\n * This returns `true` if the iterator was reset to the given state and\n * `false` otherwise.\n */\n resetState(stateId) {\n return Boolean(C._ts_lookahead_iterator_reset_state(this[0], stateId));\n }\n /**\n * Returns an iterator that iterates over the symbols of the lookahead iterator.\n *\n * The iterator will yield the current symbol name as a string for each step\n * until there are no more symbols to iterate over.\n */\n [Symbol.iterator]() {\n return {\n next: /* @__PURE__ */ __name(() => {\n if (C._ts_lookahead_iterator_next(this[0])) {\n return { done: false, value: this.currentType };\n }\n return { done: true, value: \"\" };\n }, \"next\")\n };\n }\n};\n\n// src/tree.ts\nfunction getText(tree, startIndex, endIndex, startPosition) {\n const length = endIndex - startIndex;\n let result = tree.textCallback(startIndex, startPosition);\n if (result) {\n startIndex += result.length;\n while (startIndex < endIndex) {\n const string = tree.textCallback(startIndex, startPosition);\n if (string && string.length > 0) {\n startIndex += string.length;\n result += string;\n } else {\n break;\n }\n }\n if (startIndex > endIndex) {\n result = result.slice(0, length);\n }\n }\n return result ?? \"\";\n}\n__name(getText, \"getText\");\nvar Tree = class _Tree {\n static {\n __name(this, \"Tree\");\n }\n /** @internal */\n [0] = 0;\n // Internal handle for WASM\n /** @internal */\n textCallback;\n /** The language that was used to parse the syntax tree. */\n language;\n /** @internal */\n constructor(internal, address, language, textCallback) {\n assertInternal(internal);\n this[0] = address;\n this.language = language;\n this.textCallback = textCallback;\n }\n /** Create a shallow copy of the syntax tree. This is very fast. */\n copy() {\n const address = C._ts_tree_copy(this[0]);\n return new _Tree(INTERNAL, address, this.language, this.textCallback);\n }\n /** Delete the syntax tree, freeing its resources. */\n delete() {\n C._ts_tree_delete(this[0]);\n this[0] = 0;\n }\n /** Get the root node of the syntax tree. */\n get rootNode() {\n C._ts_tree_root_node_wasm(this[0]);\n return unmarshalNode(this);\n }\n /**\n * Get the root node of the syntax tree, but with its position shifted\n * forward by the given offset.\n */\n rootNodeWithOffset(offsetBytes, offsetExtent) {\n const address = TRANSFER_BUFFER + SIZE_OF_NODE;\n C.setValue(address, offsetBytes, \"i32\");\n marshalPoint(address + SIZE_OF_INT, offsetExtent);\n C._ts_tree_root_node_with_offset_wasm(this[0]);\n return unmarshalNode(this);\n }\n /**\n * Edit the syntax tree to keep it in sync with source code that has been\n * edited.\n *\n * You must describe the edit both in terms of byte offsets and in terms of\n * row/column coordinates.\n */\n edit(edit) {\n marshalEdit(edit);\n C._ts_tree_edit_wasm(this[0]);\n }\n /** Create a new {@link TreeCursor} starting from the root of the tree. */\n walk() {\n return this.rootNode.walk();\n }\n /**\n * Compare this old edited syntax tree to a new syntax tree representing\n * the same document, returning a sequence of ranges whose syntactic\n * structure has changed.\n *\n * For this to work correctly, this syntax tree must have been edited such\n * that its ranges match up to the new tree. Generally, you'll want to\n * call this method right after calling one of the [`Parser::parse`]\n * functions. Call it on the old tree that was passed to parse, and\n * pass the new tree that was returned from `parse`.\n */\n getChangedRanges(other) {\n if (!(other instanceof _Tree)) {\n throw new TypeError(\"Argument must be a Tree\");\n }\n C._ts_tree_get_changed_ranges_wasm(this[0], other[0]);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const result = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n result[i2] = unmarshalRange(address);\n address += SIZE_OF_RANGE;\n }\n C._free(buffer);\n }\n return result;\n }\n /** Get the included ranges that were used to parse the syntax tree. */\n getIncludedRanges() {\n C._ts_tree_included_ranges_wasm(this[0]);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const result = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n result[i2] = unmarshalRange(address);\n address += SIZE_OF_RANGE;\n }\n C._free(buffer);\n }\n return result;\n }\n};\n\n// src/tree_cursor.ts\nvar TreeCursor = class _TreeCursor {\n static {\n __name(this, \"TreeCursor\");\n }\n /** @internal */\n [0] = 0;\n // Internal handle for WASM\n /** @internal */\n [1] = 0;\n // Internal handle for WASM\n /** @internal */\n [2] = 0;\n // Internal handle for WASM\n /** @internal */\n [3] = 0;\n // Internal handle for WASM\n /** @internal */\n tree;\n /** @internal */\n constructor(internal, tree) {\n assertInternal(internal);\n this.tree = tree;\n unmarshalTreeCursor(this);\n }\n /** Creates a deep copy of the tree cursor. This allocates new memory. */\n copy() {\n const copy = new _TreeCursor(INTERNAL, this.tree);\n C._ts_tree_cursor_copy_wasm(this.tree[0]);\n unmarshalTreeCursor(copy);\n return copy;\n }\n /** Delete the tree cursor, freeing its resources. */\n delete() {\n marshalTreeCursor(this);\n C._ts_tree_cursor_delete_wasm(this.tree[0]);\n this[0] = this[1] = this[2] = 0;\n }\n /** Get the tree cursor's current {@link Node}. */\n get currentNode() {\n marshalTreeCursor(this);\n C._ts_tree_cursor_current_node_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /**\n * Get the numerical field id of this tree cursor's current node.\n *\n * See also {@link TreeCursor#currentFieldName}.\n */\n get currentFieldId() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_field_id_wasm(this.tree[0]);\n }\n /** Get the field name of this tree cursor's current node. */\n get currentFieldName() {\n return this.tree.language.fields[this.currentFieldId];\n }\n /**\n * Get the depth of the cursor's current node relative to the original\n * node that the cursor was constructed with.\n */\n get currentDepth() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_depth_wasm(this.tree[0]);\n }\n /**\n * Get the index of the cursor's current node out of all of the\n * descendants of the original node that the cursor was constructed with.\n */\n get currentDescendantIndex() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_descendant_index_wasm(this.tree[0]);\n }\n /** Get the type of the cursor's current node. */\n get nodeType() {\n return this.tree.language.types[this.nodeTypeId] || \"ERROR\";\n }\n /** Get the type id of the cursor's current node. */\n get nodeTypeId() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_node_type_id_wasm(this.tree[0]);\n }\n /** Get the state id of the cursor's current node. */\n get nodeStateId() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_node_state_id_wasm(this.tree[0]);\n }\n /** Get the id of the cursor's current node. */\n get nodeId() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_node_id_wasm(this.tree[0]);\n }\n /**\n * Check if the cursor's current node is *named*.\n *\n * Named nodes correspond to named rules in the grammar, whereas\n * *anonymous* nodes correspond to string literals in the grammar.\n */\n get nodeIsNamed() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_node_is_named_wasm(this.tree[0]) === 1;\n }\n /**\n * Check if the cursor's current node is *missing*.\n *\n * Missing nodes are inserted by the parser in order to recover from\n * certain kinds of syntax errors.\n */\n get nodeIsMissing() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_current_node_is_missing_wasm(this.tree[0]) === 1;\n }\n /** Get the string content of the cursor's current node. */\n get nodeText() {\n marshalTreeCursor(this);\n const startIndex = C._ts_tree_cursor_start_index_wasm(this.tree[0]);\n const endIndex = C._ts_tree_cursor_end_index_wasm(this.tree[0]);\n C._ts_tree_cursor_start_position_wasm(this.tree[0]);\n const startPosition = unmarshalPoint(TRANSFER_BUFFER);\n return getText(this.tree, startIndex, endIndex, startPosition);\n }\n /** Get the start position of the cursor's current node. */\n get startPosition() {\n marshalTreeCursor(this);\n C._ts_tree_cursor_start_position_wasm(this.tree[0]);\n return unmarshalPoint(TRANSFER_BUFFER);\n }\n /** Get the end position of the cursor's current node. */\n get endPosition() {\n marshalTreeCursor(this);\n C._ts_tree_cursor_end_position_wasm(this.tree[0]);\n return unmarshalPoint(TRANSFER_BUFFER);\n }\n /** Get the start index of the cursor's current node. */\n get startIndex() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_start_index_wasm(this.tree[0]);\n }\n /** Get the end index of the cursor's current node. */\n get endIndex() {\n marshalTreeCursor(this);\n return C._ts_tree_cursor_end_index_wasm(this.tree[0]);\n }\n /**\n * Move this cursor to the first child of its current node.\n *\n * This returns `true` if the cursor successfully moved, and returns\n * `false` if there were no children.\n */\n gotoFirstChild() {\n marshalTreeCursor(this);\n const result = C._ts_tree_cursor_goto_first_child_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n return result === 1;\n }\n /**\n * Move this cursor to the last child of its current node.\n *\n * This returns `true` if the cursor successfully moved, and returns\n * `false` if there were no children.\n *\n * Note that this function may be slower than\n * {@link TreeCursor#gotoFirstChild} because it needs to\n * iterate through all the children to compute the child's position.\n */\n gotoLastChild() {\n marshalTreeCursor(this);\n const result = C._ts_tree_cursor_goto_last_child_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n return result === 1;\n }\n /**\n * Move this cursor to the parent of its current node.\n *\n * This returns `true` if the cursor successfully moved, and returns\n * `false` if there was no parent node (the cursor was already on the\n * root node).\n *\n * Note that the node the cursor was constructed with is considered the root\n * of the cursor, and the cursor cannot walk outside this node.\n */\n gotoParent() {\n marshalTreeCursor(this);\n const result = C._ts_tree_cursor_goto_parent_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n return result === 1;\n }\n /**\n * Move this cursor to the next sibling of its current node.\n *\n * This returns `true` if the cursor successfully moved, and returns\n * `false` if there was no next sibling node.\n *\n * Note that the node the cursor was constructed with is considered the root\n * of the cursor, and the cursor cannot walk outside this node.\n */\n gotoNextSibling() {\n marshalTreeCursor(this);\n const result = C._ts_tree_cursor_goto_next_sibling_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n return result === 1;\n }\n /**\n * Move this cursor to the previous sibling of its current node.\n *\n * This returns `true` if the cursor successfully moved, and returns\n * `false` if there was no previous sibling node.\n *\n * Note that this function may be slower than\n * {@link TreeCursor#gotoNextSibling} due to how node\n * positions are stored. In the worst case, this will need to iterate\n * through all the children up to the previous sibling node to recalculate\n * its position. Also note that the node the cursor was constructed with is\n * considered the root of the cursor, and the cursor cannot walk outside this node.\n */\n gotoPreviousSibling() {\n marshalTreeCursor(this);\n const result = C._ts_tree_cursor_goto_previous_sibling_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n return result === 1;\n }\n /**\n * Move the cursor to the node that is the nth descendant of\n * the original node that the cursor was constructed with, where\n * zero represents the original node itself.\n */\n gotoDescendant(goalDescendantIndex) {\n marshalTreeCursor(this);\n C._ts_tree_cursor_goto_descendant_wasm(this.tree[0], goalDescendantIndex);\n unmarshalTreeCursor(this);\n }\n /**\n * Move this cursor to the first child of its current node that contains or\n * starts after the given byte offset.\n *\n * This returns `true` if the cursor successfully moved to a child node, and returns\n * `false` if no such child was found.\n */\n gotoFirstChildForIndex(goalIndex) {\n marshalTreeCursor(this);\n C.setValue(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalIndex, \"i32\");\n const result = C._ts_tree_cursor_goto_first_child_for_index_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n return result === 1;\n }\n /**\n * Move this cursor to the first child of its current node that contains or\n * starts after the given byte offset.\n *\n * This returns the index of the child node if one was found, and returns\n * `null` if no such child was found.\n */\n gotoFirstChildForPosition(goalPosition) {\n marshalTreeCursor(this);\n marshalPoint(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalPosition);\n const result = C._ts_tree_cursor_goto_first_child_for_position_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n return result === 1;\n }\n /**\n * Re-initialize this tree cursor to start at the original node that the\n * cursor was constructed with.\n */\n reset(node) {\n marshalNode(node);\n marshalTreeCursor(this, TRANSFER_BUFFER + SIZE_OF_NODE);\n C._ts_tree_cursor_reset_wasm(this.tree[0]);\n unmarshalTreeCursor(this);\n }\n /**\n * Re-initialize a tree cursor to the same position as another cursor.\n *\n * Unlike {@link TreeCursor#reset}, this will not lose parent\n * information and allows reusing already created cursors.\n */\n resetTo(cursor) {\n marshalTreeCursor(this, TRANSFER_BUFFER);\n marshalTreeCursor(cursor, TRANSFER_BUFFER + SIZE_OF_CURSOR);\n C._ts_tree_cursor_reset_to_wasm(this.tree[0], cursor.tree[0]);\n unmarshalTreeCursor(this);\n }\n};\n\n// src/node.ts\nvar Node = class {\n static {\n __name(this, \"Node\");\n }\n /** @internal */\n [0] = 0;\n // Internal handle for WASM\n /** @internal */\n _children;\n /** @internal */\n _namedChildren;\n /** @internal */\n constructor(internal, {\n id,\n tree,\n startIndex,\n startPosition,\n other\n }) {\n assertInternal(internal);\n this[0] = other;\n this.id = id;\n this.tree = tree;\n this.startIndex = startIndex;\n this.startPosition = startPosition;\n }\n /**\n * The numeric id for this node that is unique.\n *\n * Within a given syntax tree, no two nodes have the same id. However:\n *\n * * If a new tree is created based on an older tree, and a node from the old tree is reused in\n * the process, then that node will have the same id in both trees.\n *\n * * A node not marked as having changes does not guarantee it was reused.\n *\n * * If a node is marked as having changed in the old tree, it will not be reused.\n */\n id;\n /** The byte index where this node starts. */\n startIndex;\n /** The position where this node starts. */\n startPosition;\n /** The tree that this node belongs to. */\n tree;\n /** Get this node's type as a numerical id. */\n get typeId() {\n marshalNode(this);\n return C._ts_node_symbol_wasm(this.tree[0]);\n }\n /**\n * Get the node's type as a numerical id as it appears in the grammar,\n * ignoring aliases.\n */\n get grammarId() {\n marshalNode(this);\n return C._ts_node_grammar_symbol_wasm(this.tree[0]);\n }\n /** Get this node's type as a string. */\n get type() {\n return this.tree.language.types[this.typeId] || \"ERROR\";\n }\n /**\n * Get this node's symbol name as it appears in the grammar, ignoring\n * aliases as a string.\n */\n get grammarType() {\n return this.tree.language.types[this.grammarId] || \"ERROR\";\n }\n /**\n * Check if this node is *named*.\n *\n * Named nodes correspond to named rules in the grammar, whereas\n * *anonymous* nodes correspond to string literals in the grammar.\n */\n get isNamed() {\n marshalNode(this);\n return C._ts_node_is_named_wasm(this.tree[0]) === 1;\n }\n /**\n * Check if this node is *extra*.\n *\n * Extra nodes represent things like comments, which are not required\n * by the grammar, but can appear anywhere.\n */\n get isExtra() {\n marshalNode(this);\n return C._ts_node_is_extra_wasm(this.tree[0]) === 1;\n }\n /**\n * Check if this node represents a syntax error.\n *\n * Syntax errors represent parts of the code that could not be incorporated\n * into a valid syntax tree.\n */\n get isError() {\n marshalNode(this);\n return C._ts_node_is_error_wasm(this.tree[0]) === 1;\n }\n /**\n * Check if this node is *missing*.\n *\n * Missing nodes are inserted by the parser in order to recover from\n * certain kinds of syntax errors.\n */\n get isMissing() {\n marshalNode(this);\n return C._ts_node_is_missing_wasm(this.tree[0]) === 1;\n }\n /** Check if this node has been edited. */\n get hasChanges() {\n marshalNode(this);\n return C._ts_node_has_changes_wasm(this.tree[0]) === 1;\n }\n /**\n * Check if this node represents a syntax error or contains any syntax\n * errors anywhere within it.\n */\n get hasError() {\n marshalNode(this);\n return C._ts_node_has_error_wasm(this.tree[0]) === 1;\n }\n /** Get the byte index where this node ends. */\n get endIndex() {\n marshalNode(this);\n return C._ts_node_end_index_wasm(this.tree[0]);\n }\n /** Get the position where this node ends. */\n get endPosition() {\n marshalNode(this);\n C._ts_node_end_point_wasm(this.tree[0]);\n return unmarshalPoint(TRANSFER_BUFFER);\n }\n /** Get the string content of this node. */\n get text() {\n return getText(this.tree, this.startIndex, this.endIndex, this.startPosition);\n }\n /** Get this node's parse state. */\n get parseState() {\n marshalNode(this);\n return C._ts_node_parse_state_wasm(this.tree[0]);\n }\n /** Get the parse state after this node. */\n get nextParseState() {\n marshalNode(this);\n return C._ts_node_next_parse_state_wasm(this.tree[0]);\n }\n /** Check if this node is equal to another node. */\n equals(other) {\n return this.tree === other.tree && this.id === other.id;\n }\n /**\n * Get the node's child at the given index, where zero represents the first child.\n *\n * This method is fairly fast, but its cost is technically log(n), so if\n * you might be iterating over a long list of children, you should use\n * {@link Node#children} instead.\n */\n child(index) {\n marshalNode(this);\n C._ts_node_child_wasm(this.tree[0], index);\n return unmarshalNode(this.tree);\n }\n /**\n * Get this node's *named* child at the given index.\n *\n * See also {@link Node#isNamed}.\n * This method is fairly fast, but its cost is technically log(n), so if\n * you might be iterating over a long list of children, you should use\n * {@link Node#namedChildren} instead.\n */\n namedChild(index) {\n marshalNode(this);\n C._ts_node_named_child_wasm(this.tree[0], index);\n return unmarshalNode(this.tree);\n }\n /**\n * Get this node's child with the given numerical field id.\n *\n * See also {@link Node#childForFieldName}. You can\n * convert a field name to an id using {@link Language#fieldIdForName}.\n */\n childForFieldId(fieldId) {\n marshalNode(this);\n C._ts_node_child_by_field_id_wasm(this.tree[0], fieldId);\n return unmarshalNode(this.tree);\n }\n /**\n * Get the first child with the given field name.\n *\n * If multiple children may have the same field name, access them using\n * {@link Node#childrenForFieldName}.\n */\n childForFieldName(fieldName) {\n const fieldId = this.tree.language.fields.indexOf(fieldName);\n if (fieldId !== -1) return this.childForFieldId(fieldId);\n return null;\n }\n /** Get the field name of this node's child at the given index. */\n fieldNameForChild(index) {\n marshalNode(this);\n const address = C._ts_node_field_name_for_child_wasm(this.tree[0], index);\n if (!address) return null;\n return C.AsciiToString(address);\n }\n /** Get the field name of this node's named child at the given index. */\n fieldNameForNamedChild(index) {\n marshalNode(this);\n const address = C._ts_node_field_name_for_named_child_wasm(this.tree[0], index);\n if (!address) return null;\n return C.AsciiToString(address);\n }\n /**\n * Get an array of this node's children with a given field name.\n *\n * See also {@link Node#children}.\n */\n childrenForFieldName(fieldName) {\n const fieldId = this.tree.language.fields.indexOf(fieldName);\n if (fieldId !== -1 && fieldId !== 0) return this.childrenForFieldId(fieldId);\n return [];\n }\n /**\n * Get an array of this node's children with a given field id.\n *\n * See also {@link Node#childrenForFieldName}.\n */\n childrenForFieldId(fieldId) {\n marshalNode(this);\n C._ts_node_children_by_field_id_wasm(this.tree[0], fieldId);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const result = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n result[i2] = unmarshalNode(this.tree, address);\n address += SIZE_OF_NODE;\n }\n C._free(buffer);\n }\n return result;\n }\n /** Get the node's first child that contains or starts after the given byte offset. */\n firstChildForIndex(index) {\n marshalNode(this);\n const address = TRANSFER_BUFFER + SIZE_OF_NODE;\n C.setValue(address, index, \"i32\");\n C._ts_node_first_child_for_byte_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get the node's first named child that contains or starts after the given byte offset. */\n firstNamedChildForIndex(index) {\n marshalNode(this);\n const address = TRANSFER_BUFFER + SIZE_OF_NODE;\n C.setValue(address, index, \"i32\");\n C._ts_node_first_named_child_for_byte_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get this node's number of children. */\n get childCount() {\n marshalNode(this);\n return C._ts_node_child_count_wasm(this.tree[0]);\n }\n /**\n * Get this node's number of *named* children.\n *\n * See also {@link Node#isNamed}.\n */\n get namedChildCount() {\n marshalNode(this);\n return C._ts_node_named_child_count_wasm(this.tree[0]);\n }\n /** Get this node's first child. */\n get firstChild() {\n return this.child(0);\n }\n /**\n * Get this node's first named child.\n *\n * See also {@link Node#isNamed}.\n */\n get firstNamedChild() {\n return this.namedChild(0);\n }\n /** Get this node's last child. */\n get lastChild() {\n return this.child(this.childCount - 1);\n }\n /**\n * Get this node's last named child.\n *\n * See also {@link Node#isNamed}.\n */\n get lastNamedChild() {\n return this.namedChild(this.namedChildCount - 1);\n }\n /**\n * Iterate over this node's children.\n *\n * If you're walking the tree recursively, you may want to use the\n * {@link TreeCursor} APIs directly instead.\n */\n get children() {\n if (!this._children) {\n marshalNode(this);\n C._ts_node_children_wasm(this.tree[0]);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n this._children = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n this._children[i2] = unmarshalNode(this.tree, address);\n address += SIZE_OF_NODE;\n }\n C._free(buffer);\n }\n }\n return this._children;\n }\n /**\n * Iterate over this node's named children.\n *\n * See also {@link Node#children}.\n */\n get namedChildren() {\n if (!this._namedChildren) {\n marshalNode(this);\n C._ts_node_named_children_wasm(this.tree[0]);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n this._namedChildren = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n this._namedChildren[i2] = unmarshalNode(this.tree, address);\n address += SIZE_OF_NODE;\n }\n C._free(buffer);\n }\n }\n return this._namedChildren;\n }\n /**\n * Get the descendants of this node that are the given type, or in the given types array.\n *\n * The types array should contain node type strings, which can be retrieved from {@link Language#types}.\n *\n * Additionally, a `startPosition` and `endPosition` can be passed in to restrict the search to a byte range.\n */\n descendantsOfType(types, startPosition = ZERO_POINT, endPosition = ZERO_POINT) {\n if (!Array.isArray(types)) types = [types];\n const symbols = [];\n const typesBySymbol = this.tree.language.types;\n for (const node_type of types) {\n if (node_type == \"ERROR\") {\n symbols.push(65535);\n }\n }\n for (let i2 = 0, n = typesBySymbol.length; i2 < n; i2++) {\n if (types.includes(typesBySymbol[i2])) {\n symbols.push(i2);\n }\n }\n const symbolsAddress = C._malloc(SIZE_OF_INT * symbols.length);\n for (let i2 = 0, n = symbols.length; i2 < n; i2++) {\n C.setValue(symbolsAddress + i2 * SIZE_OF_INT, symbols[i2], \"i32\");\n }\n marshalNode(this);\n C._ts_node_descendants_of_type_wasm(\n this.tree[0],\n symbolsAddress,\n symbols.length,\n startPosition.row,\n startPosition.column,\n endPosition.row,\n endPosition.column\n );\n const descendantCount = C.getValue(TRANSFER_BUFFER, \"i32\");\n const descendantAddress = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const result = new Array(descendantCount);\n if (descendantCount > 0) {\n let address = descendantAddress;\n for (let i2 = 0; i2 < descendantCount; i2++) {\n result[i2] = unmarshalNode(this.tree, address);\n address += SIZE_OF_NODE;\n }\n }\n C._free(descendantAddress);\n C._free(symbolsAddress);\n return result;\n }\n /** Get this node's next sibling. */\n get nextSibling() {\n marshalNode(this);\n C._ts_node_next_sibling_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get this node's previous sibling. */\n get previousSibling() {\n marshalNode(this);\n C._ts_node_prev_sibling_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /**\n * Get this node's next *named* sibling.\n *\n * See also {@link Node#isNamed}.\n */\n get nextNamedSibling() {\n marshalNode(this);\n C._ts_node_next_named_sibling_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /**\n * Get this node's previous *named* sibling.\n *\n * See also {@link Node#isNamed}.\n */\n get previousNamedSibling() {\n marshalNode(this);\n C._ts_node_prev_named_sibling_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get the node's number of descendants, including one for the node itself. */\n get descendantCount() {\n marshalNode(this);\n return C._ts_node_descendant_count_wasm(this.tree[0]);\n }\n /**\n * Get this node's immediate parent.\n * Prefer {@link Node#childWithDescendant} for iterating over this node's ancestors.\n */\n get parent() {\n marshalNode(this);\n C._ts_node_parent_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /**\n * Get the node that contains `descendant`.\n *\n * Note that this can return `descendant` itself.\n */\n childWithDescendant(descendant) {\n marshalNode(this);\n marshalNode(descendant, 1);\n C._ts_node_child_with_descendant_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get the smallest node within this node that spans the given byte range. */\n descendantForIndex(start2, end = start2) {\n if (typeof start2 !== \"number\" || typeof end !== \"number\") {\n throw new Error(\"Arguments must be numbers\");\n }\n marshalNode(this);\n const address = TRANSFER_BUFFER + SIZE_OF_NODE;\n C.setValue(address, start2, \"i32\");\n C.setValue(address + SIZE_OF_INT, end, \"i32\");\n C._ts_node_descendant_for_index_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get the smallest named node within this node that spans the given byte range. */\n namedDescendantForIndex(start2, end = start2) {\n if (typeof start2 !== \"number\" || typeof end !== \"number\") {\n throw new Error(\"Arguments must be numbers\");\n }\n marshalNode(this);\n const address = TRANSFER_BUFFER + SIZE_OF_NODE;\n C.setValue(address, start2, \"i32\");\n C.setValue(address + SIZE_OF_INT, end, \"i32\");\n C._ts_node_named_descendant_for_index_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get the smallest node within this node that spans the given point range. */\n descendantForPosition(start2, end = start2) {\n if (!isPoint(start2) || !isPoint(end)) {\n throw new Error(\"Arguments must be {row, column} objects\");\n }\n marshalNode(this);\n const address = TRANSFER_BUFFER + SIZE_OF_NODE;\n marshalPoint(address, start2);\n marshalPoint(address + SIZE_OF_POINT, end);\n C._ts_node_descendant_for_position_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /** Get the smallest named node within this node that spans the given point range. */\n namedDescendantForPosition(start2, end = start2) {\n if (!isPoint(start2) || !isPoint(end)) {\n throw new Error(\"Arguments must be {row, column} objects\");\n }\n marshalNode(this);\n const address = TRANSFER_BUFFER + SIZE_OF_NODE;\n marshalPoint(address, start2);\n marshalPoint(address + SIZE_OF_POINT, end);\n C._ts_node_named_descendant_for_position_wasm(this.tree[0]);\n return unmarshalNode(this.tree);\n }\n /**\n * Create a new {@link TreeCursor} starting from this node.\n *\n * Note that the given node is considered the root of the cursor,\n * and the cursor cannot walk outside this node.\n */\n walk() {\n marshalNode(this);\n C._ts_tree_cursor_new_wasm(this.tree[0]);\n return new TreeCursor(INTERNAL, this.tree);\n }\n /**\n * Edit this node to keep it in-sync with source code that has been edited.\n *\n * This function is only rarely needed. When you edit a syntax tree with\n * the {@link Tree#edit} method, all of the nodes that you retrieve from\n * the tree afterward will already reflect the edit. You only need to\n * use {@link Node#edit} when you have a specific {@link Node} instance that\n * you want to keep and continue to use after an edit.\n */\n edit(edit) {\n if (this.startIndex >= edit.oldEndIndex) {\n this.startIndex = edit.newEndIndex + (this.startIndex - edit.oldEndIndex);\n let subbedPointRow;\n let subbedPointColumn;\n if (this.startPosition.row > edit.oldEndPosition.row) {\n subbedPointRow = this.startPosition.row - edit.oldEndPosition.row;\n subbedPointColumn = this.startPosition.column;\n } else {\n subbedPointRow = 0;\n subbedPointColumn = this.startPosition.column;\n if (this.startPosition.column >= edit.oldEndPosition.column) {\n subbedPointColumn = this.startPosition.column - edit.oldEndPosition.column;\n }\n }\n if (subbedPointRow > 0) {\n this.startPosition.row += subbedPointRow;\n this.startPosition.column = subbedPointColumn;\n } else {\n this.startPosition.column += subbedPointColumn;\n }\n } else if (this.startIndex > edit.startIndex) {\n this.startIndex = edit.newEndIndex;\n this.startPosition.row = edit.newEndPosition.row;\n this.startPosition.column = edit.newEndPosition.column;\n }\n }\n /** Get the S-expression representation of this node. */\n toString() {\n marshalNode(this);\n const address = C._ts_node_to_string_wasm(this.tree[0]);\n const result = C.AsciiToString(address);\n C._free(address);\n return result;\n }\n};\n\n// src/marshal.ts\nfunction unmarshalCaptures(query, tree, address, patternIndex, result) {\n for (let i2 = 0, n = result.length; i2 < n; i2++) {\n const captureIndex = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const node = unmarshalNode(tree, address);\n address += SIZE_OF_NODE;\n result[i2] = { patternIndex, name: query.captureNames[captureIndex], node };\n }\n return address;\n}\n__name(unmarshalCaptures, \"unmarshalCaptures\");\nfunction marshalNode(node, index = 0) {\n let address = TRANSFER_BUFFER + index * SIZE_OF_NODE;\n C.setValue(address, node.id, \"i32\");\n address += SIZE_OF_INT;\n C.setValue(address, node.startIndex, \"i32\");\n address += SIZE_OF_INT;\n C.setValue(address, node.startPosition.row, \"i32\");\n address += SIZE_OF_INT;\n C.setValue(address, node.startPosition.column, \"i32\");\n address += SIZE_OF_INT;\n C.setValue(address, node[0], \"i32\");\n}\n__name(marshalNode, \"marshalNode\");\nfunction unmarshalNode(tree, address = TRANSFER_BUFFER) {\n const id = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n if (id === 0) return null;\n const index = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const row = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const column = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const other = C.getValue(address, \"i32\");\n const result = new Node(INTERNAL, {\n id,\n tree,\n startIndex: index,\n startPosition: { row, column },\n other\n });\n return result;\n}\n__name(unmarshalNode, \"unmarshalNode\");\nfunction marshalTreeCursor(cursor, address = TRANSFER_BUFFER) {\n C.setValue(address + 0 * SIZE_OF_INT, cursor[0], \"i32\");\n C.setValue(address + 1 * SIZE_OF_INT, cursor[1], \"i32\");\n C.setValue(address + 2 * SIZE_OF_INT, cursor[2], \"i32\");\n C.setValue(address + 3 * SIZE_OF_INT, cursor[3], \"i32\");\n}\n__name(marshalTreeCursor, \"marshalTreeCursor\");\nfunction unmarshalTreeCursor(cursor) {\n cursor[0] = C.getValue(TRANSFER_BUFFER + 0 * SIZE_OF_INT, \"i32\");\n cursor[1] = C.getValue(TRANSFER_BUFFER + 1 * SIZE_OF_INT, \"i32\");\n cursor[2] = C.getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, \"i32\");\n cursor[3] = C.getValue(TRANSFER_BUFFER + 3 * SIZE_OF_INT, \"i32\");\n}\n__name(unmarshalTreeCursor, \"unmarshalTreeCursor\");\nfunction marshalPoint(address, point) {\n C.setValue(address, point.row, \"i32\");\n C.setValue(address + SIZE_OF_INT, point.column, \"i32\");\n}\n__name(marshalPoint, \"marshalPoint\");\nfunction unmarshalPoint(address) {\n const result = {\n row: C.getValue(address, \"i32\") >>> 0,\n column: C.getValue(address + SIZE_OF_INT, \"i32\") >>> 0\n };\n return result;\n}\n__name(unmarshalPoint, \"unmarshalPoint\");\nfunction marshalRange(address, range) {\n marshalPoint(address, range.startPosition);\n address += SIZE_OF_POINT;\n marshalPoint(address, range.endPosition);\n address += SIZE_OF_POINT;\n C.setValue(address, range.startIndex, \"i32\");\n address += SIZE_OF_INT;\n C.setValue(address, range.endIndex, \"i32\");\n address += SIZE_OF_INT;\n}\n__name(marshalRange, \"marshalRange\");\nfunction unmarshalRange(address) {\n const result = {};\n result.startPosition = unmarshalPoint(address);\n address += SIZE_OF_POINT;\n result.endPosition = unmarshalPoint(address);\n address += SIZE_OF_POINT;\n result.startIndex = C.getValue(address, \"i32\") >>> 0;\n address += SIZE_OF_INT;\n result.endIndex = C.getValue(address, \"i32\") >>> 0;\n return result;\n}\n__name(unmarshalRange, \"unmarshalRange\");\nfunction marshalEdit(edit, address = TRANSFER_BUFFER) {\n marshalPoint(address, edit.startPosition);\n address += SIZE_OF_POINT;\n marshalPoint(address, edit.oldEndPosition);\n address += SIZE_OF_POINT;\n marshalPoint(address, edit.newEndPosition);\n address += SIZE_OF_POINT;\n C.setValue(address, edit.startIndex, \"i32\");\n address += SIZE_OF_INT;\n C.setValue(address, edit.oldEndIndex, \"i32\");\n address += SIZE_OF_INT;\n C.setValue(address, edit.newEndIndex, \"i32\");\n address += SIZE_OF_INT;\n}\n__name(marshalEdit, \"marshalEdit\");\nfunction unmarshalLanguageMetadata(address) {\n const result = {};\n result.major_version = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n result.minor_version = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n result.field_count = C.getValue(address, \"i32\");\n return result;\n}\n__name(unmarshalLanguageMetadata, \"unmarshalLanguageMetadata\");\n\n// src/query.ts\nvar PREDICATE_STEP_TYPE_CAPTURE = 1;\nvar PREDICATE_STEP_TYPE_STRING = 2;\nvar QUERY_WORD_REGEX = /[\\w-]+/g;\nvar CaptureQuantifier = {\n Zero: 0,\n ZeroOrOne: 1,\n ZeroOrMore: 2,\n One: 3,\n OneOrMore: 4\n};\nvar isCaptureStep = /* @__PURE__ */ __name((step) => step.type === \"capture\", \"isCaptureStep\");\nvar isStringStep = /* @__PURE__ */ __name((step) => step.type === \"string\", \"isStringStep\");\nvar QueryErrorKind = {\n Syntax: 1,\n NodeName: 2,\n FieldName: 3,\n CaptureName: 4,\n PatternStructure: 5\n};\nvar QueryError = class _QueryError extends Error {\n constructor(kind, info2, index, length) {\n super(_QueryError.formatMessage(kind, info2));\n this.kind = kind;\n this.info = info2;\n this.index = index;\n this.length = length;\n this.name = \"QueryError\";\n }\n static {\n __name(this, \"QueryError\");\n }\n /** Formats an error message based on the error kind and info */\n static formatMessage(kind, info2) {\n switch (kind) {\n case QueryErrorKind.NodeName:\n return `Bad node name '${info2.word}'`;\n case QueryErrorKind.FieldName:\n return `Bad field name '${info2.word}'`;\n case QueryErrorKind.CaptureName:\n return `Bad capture name @${info2.word}`;\n case QueryErrorKind.PatternStructure:\n return `Bad pattern structure at offset ${info2.suffix}`;\n case QueryErrorKind.Syntax:\n return `Bad syntax at offset ${info2.suffix}`;\n }\n }\n};\nfunction parseAnyPredicate(steps, index, operator, textPredicates) {\n if (steps.length !== 3) {\n throw new Error(\n `Wrong number of arguments to \\`#${operator}\\` predicate. Expected 2, got ${steps.length - 1}`\n );\n }\n if (!isCaptureStep(steps[1])) {\n throw new Error(\n `First argument of \\`#${operator}\\` predicate must be a capture. Got \"${steps[1].value}\"`\n );\n }\n const isPositive = operator === \"eq?\" || operator === \"any-eq?\";\n const matchAll = !operator.startsWith(\"any-\");\n if (isCaptureStep(steps[2])) {\n const captureName1 = steps[1].name;\n const captureName2 = steps[2].name;\n textPredicates[index].push((captures) => {\n const nodes1 = [];\n const nodes2 = [];\n for (const c of captures) {\n if (c.name === captureName1) nodes1.push(c.node);\n if (c.name === captureName2) nodes2.push(c.node);\n }\n const compare = /* @__PURE__ */ __name((n1, n2, positive) => {\n return positive ? n1.text === n2.text : n1.text !== n2.text;\n }, \"compare\");\n return matchAll ? nodes1.every((n1) => nodes2.some((n2) => compare(n1, n2, isPositive))) : nodes1.some((n1) => nodes2.some((n2) => compare(n1, n2, isPositive)));\n });\n } else {\n const captureName = steps[1].name;\n const stringValue = steps[2].value;\n const matches = /* @__PURE__ */ __name((n) => n.text === stringValue, \"matches\");\n const doesNotMatch = /* @__PURE__ */ __name((n) => n.text !== stringValue, \"doesNotMatch\");\n textPredicates[index].push((captures) => {\n const nodes = [];\n for (const c of captures) {\n if (c.name === captureName) nodes.push(c.node);\n }\n const test = isPositive ? matches : doesNotMatch;\n return matchAll ? nodes.every(test) : nodes.some(test);\n });\n }\n}\n__name(parseAnyPredicate, \"parseAnyPredicate\");\nfunction parseMatchPredicate(steps, index, operator, textPredicates) {\n if (steps.length !== 3) {\n throw new Error(\n `Wrong number of arguments to \\`#${operator}\\` predicate. Expected 2, got ${steps.length - 1}.`\n );\n }\n if (steps[1].type !== \"capture\") {\n throw new Error(\n `First argument of \\`#${operator}\\` predicate must be a capture. Got \"${steps[1].value}\".`\n );\n }\n if (steps[2].type !== \"string\") {\n throw new Error(\n `Second argument of \\`#${operator}\\` predicate must be a string. Got @${steps[2].name}.`\n );\n }\n const isPositive = operator === \"match?\" || operator === \"any-match?\";\n const matchAll = !operator.startsWith(\"any-\");\n const captureName = steps[1].name;\n const regex = new RegExp(steps[2].value);\n textPredicates[index].push((captures) => {\n const nodes = [];\n for (const c of captures) {\n if (c.name === captureName) nodes.push(c.node.text);\n }\n const test = /* @__PURE__ */ __name((text, positive) => {\n return positive ? regex.test(text) : !regex.test(text);\n }, \"test\");\n if (nodes.length === 0) return !isPositive;\n return matchAll ? nodes.every((text) => test(text, isPositive)) : nodes.some((text) => test(text, isPositive));\n });\n}\n__name(parseMatchPredicate, \"parseMatchPredicate\");\nfunction parseAnyOfPredicate(steps, index, operator, textPredicates) {\n if (steps.length < 2) {\n throw new Error(\n `Wrong number of arguments to \\`#${operator}\\` predicate. Expected at least 1. Got ${steps.length - 1}.`\n );\n }\n if (steps[1].type !== \"capture\") {\n throw new Error(\n `First argument of \\`#${operator}\\` predicate must be a capture. Got \"${steps[1].value}\".`\n );\n }\n const isPositive = operator === \"any-of?\";\n const captureName = steps[1].name;\n const stringSteps = steps.slice(2);\n if (!stringSteps.every(isStringStep)) {\n throw new Error(\n `Arguments to \\`#${operator}\\` predicate must be strings.\".`\n );\n }\n const values = stringSteps.map((s) => s.value);\n textPredicates[index].push((captures) => {\n const nodes = [];\n for (const c of captures) {\n if (c.name === captureName) nodes.push(c.node.text);\n }\n if (nodes.length === 0) return !isPositive;\n return nodes.every((text) => values.includes(text)) === isPositive;\n });\n}\n__name(parseAnyOfPredicate, \"parseAnyOfPredicate\");\nfunction parseIsPredicate(steps, index, operator, assertedProperties, refutedProperties) {\n if (steps.length < 2 || steps.length > 3) {\n throw new Error(\n `Wrong number of arguments to \\`#${operator}\\` predicate. Expected 1 or 2. Got ${steps.length - 1}.`\n );\n }\n if (!steps.every(isStringStep)) {\n throw new Error(\n `Arguments to \\`#${operator}\\` predicate must be strings.\".`\n );\n }\n const properties = operator === \"is?\" ? assertedProperties : refutedProperties;\n if (!properties[index]) properties[index] = {};\n properties[index][steps[1].value] = steps[2]?.value ?? null;\n}\n__name(parseIsPredicate, \"parseIsPredicate\");\nfunction parseSetDirective(steps, index, setProperties) {\n if (steps.length < 2 || steps.length > 3) {\n throw new Error(`Wrong number of arguments to \\`#set!\\` predicate. Expected 1 or 2. Got ${steps.length - 1}.`);\n }\n if (!steps.every(isStringStep)) {\n throw new Error(`Arguments to \\`#set!\\` predicate must be strings.\".`);\n }\n if (!setProperties[index]) setProperties[index] = {};\n setProperties[index][steps[1].value] = steps[2]?.value ?? null;\n}\n__name(parseSetDirective, \"parseSetDirective\");\nfunction parsePattern(index, stepType, stepValueId, captureNames, stringValues, steps, textPredicates, predicates, setProperties, assertedProperties, refutedProperties) {\n if (stepType === PREDICATE_STEP_TYPE_CAPTURE) {\n const name2 = captureNames[stepValueId];\n steps.push({ type: \"capture\", name: name2 });\n } else if (stepType === PREDICATE_STEP_TYPE_STRING) {\n steps.push({ type: \"string\", value: stringValues[stepValueId] });\n } else if (steps.length > 0) {\n if (steps[0].type !== \"string\") {\n throw new Error(\"Predicates must begin with a literal value\");\n }\n const operator = steps[0].value;\n switch (operator) {\n case \"any-not-eq?\":\n case \"not-eq?\":\n case \"any-eq?\":\n case \"eq?\":\n parseAnyPredicate(steps, index, operator, textPredicates);\n break;\n case \"any-not-match?\":\n case \"not-match?\":\n case \"any-match?\":\n case \"match?\":\n parseMatchPredicate(steps, index, operator, textPredicates);\n break;\n case \"not-any-of?\":\n case \"any-of?\":\n parseAnyOfPredicate(steps, index, operator, textPredicates);\n break;\n case \"is?\":\n case \"is-not?\":\n parseIsPredicate(steps, index, operator, assertedProperties, refutedProperties);\n break;\n case \"set!\":\n parseSetDirective(steps, index, setProperties);\n break;\n default:\n predicates[index].push({ operator, operands: steps.slice(1) });\n }\n steps.length = 0;\n }\n}\n__name(parsePattern, \"parsePattern\");\nvar Query = class {\n static {\n __name(this, \"Query\");\n }\n /** @internal */\n [0] = 0;\n // Internal handle for WASM\n /** @internal */\n exceededMatchLimit;\n /** @internal */\n textPredicates;\n /** The names of the captures used in the query. */\n captureNames;\n /** The quantifiers of the captures used in the query. */\n captureQuantifiers;\n /**\n * The other user-defined predicates associated with the given index.\n *\n * This includes predicates with operators other than:\n * - `match?`\n * - `eq?` and `not-eq?`\n * - `any-of?` and `not-any-of?`\n * - `is?` and `is-not?`\n * - `set!`\n */\n predicates;\n /** The properties for predicates with the operator `set!`. */\n setProperties;\n /** The properties for predicates with the operator `is?`. */\n assertedProperties;\n /** The properties for predicates with the operator `is-not?`. */\n refutedProperties;\n /** The maximum number of in-progress matches for this cursor. */\n matchLimit;\n /**\n * Create a new query from a string containing one or more S-expression\n * patterns.\n *\n * The query is associated with a particular language, and can only be run\n * on syntax nodes parsed with that language. References to Queries can be\n * shared between multiple threads.\n *\n * @link {@see https://tree-sitter.github.io/tree-sitter/using-parsers/queries}\n */\n constructor(language, source) {\n const sourceLength = C.lengthBytesUTF8(source);\n const sourceAddress = C._malloc(sourceLength + 1);\n C.stringToUTF8(source, sourceAddress, sourceLength + 1);\n const address = C._ts_query_new(\n language[0],\n sourceAddress,\n sourceLength,\n TRANSFER_BUFFER,\n TRANSFER_BUFFER + SIZE_OF_INT\n );\n if (!address) {\n const errorId = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const errorByte = C.getValue(TRANSFER_BUFFER, \"i32\");\n const errorIndex = C.UTF8ToString(sourceAddress, errorByte).length;\n const suffix = source.slice(errorIndex, errorIndex + 100).split(\"\\n\")[0];\n const word = suffix.match(QUERY_WORD_REGEX)?.[0] ?? \"\";\n C._free(sourceAddress);\n switch (errorId) {\n case QueryErrorKind.Syntax:\n throw new QueryError(QueryErrorKind.Syntax, { suffix: `${errorIndex}: '${suffix}'...` }, errorIndex, 0);\n case QueryErrorKind.NodeName:\n throw new QueryError(errorId, { word }, errorIndex, word.length);\n case QueryErrorKind.FieldName:\n throw new QueryError(errorId, { word }, errorIndex, word.length);\n case QueryErrorKind.CaptureName:\n throw new QueryError(errorId, { word }, errorIndex, word.length);\n case QueryErrorKind.PatternStructure:\n throw new QueryError(errorId, { suffix: `${errorIndex}: '${suffix}'...` }, errorIndex, 0);\n }\n }\n const stringCount = C._ts_query_string_count(address);\n const captureCount = C._ts_query_capture_count(address);\n const patternCount = C._ts_query_pattern_count(address);\n const captureNames = new Array(captureCount);\n const captureQuantifiers = new Array(patternCount);\n const stringValues = new Array(stringCount);\n for (let i2 = 0; i2 < captureCount; i2++) {\n const nameAddress = C._ts_query_capture_name_for_id(\n address,\n i2,\n TRANSFER_BUFFER\n );\n const nameLength = C.getValue(TRANSFER_BUFFER, \"i32\");\n captureNames[i2] = C.UTF8ToString(nameAddress, nameLength);\n }\n for (let i2 = 0; i2 < patternCount; i2++) {\n const captureQuantifiersArray = new Array(captureCount);\n for (let j = 0; j < captureCount; j++) {\n const quantifier = C._ts_query_capture_quantifier_for_id(address, i2, j);\n captureQuantifiersArray[j] = quantifier;\n }\n captureQuantifiers[i2] = captureQuantifiersArray;\n }\n for (let i2 = 0; i2 < stringCount; i2++) {\n const valueAddress = C._ts_query_string_value_for_id(\n address,\n i2,\n TRANSFER_BUFFER\n );\n const nameLength = C.getValue(TRANSFER_BUFFER, \"i32\");\n stringValues[i2] = C.UTF8ToString(valueAddress, nameLength);\n }\n const setProperties = new Array(patternCount);\n const assertedProperties = new Array(patternCount);\n const refutedProperties = new Array(patternCount);\n const predicates = new Array(patternCount);\n const textPredicates = new Array(patternCount);\n for (let i2 = 0; i2 < patternCount; i2++) {\n const predicatesAddress = C._ts_query_predicates_for_pattern(address, i2, TRANSFER_BUFFER);\n const stepCount = C.getValue(TRANSFER_BUFFER, \"i32\");\n predicates[i2] = [];\n textPredicates[i2] = [];\n const steps = new Array();\n let stepAddress = predicatesAddress;\n for (let j = 0; j < stepCount; j++) {\n const stepType = C.getValue(stepAddress, \"i32\");\n stepAddress += SIZE_OF_INT;\n const stepValueId = C.getValue(stepAddress, \"i32\");\n stepAddress += SIZE_OF_INT;\n parsePattern(\n i2,\n stepType,\n stepValueId,\n captureNames,\n stringValues,\n steps,\n textPredicates,\n predicates,\n setProperties,\n assertedProperties,\n refutedProperties\n );\n }\n Object.freeze(textPredicates[i2]);\n Object.freeze(predicates[i2]);\n Object.freeze(setProperties[i2]);\n Object.freeze(assertedProperties[i2]);\n Object.freeze(refutedProperties[i2]);\n }\n C._free(sourceAddress);\n this[0] = address;\n this.captureNames = captureNames;\n this.captureQuantifiers = captureQuantifiers;\n this.textPredicates = textPredicates;\n this.predicates = predicates;\n this.setProperties = setProperties;\n this.assertedProperties = assertedProperties;\n this.refutedProperties = refutedProperties;\n this.exceededMatchLimit = false;\n }\n /** Delete the query, freeing its resources. */\n delete() {\n C._ts_query_delete(this[0]);\n this[0] = 0;\n }\n /**\n * Iterate over all of the matches in the order that they were found.\n *\n * Each match contains the index of the pattern that matched, and a list of\n * captures. Because multiple patterns can match the same set of nodes,\n * one match may contain captures that appear *before* some of the\n * captures from a previous match.\n *\n * @param {Node} node - The node to execute the query on.\n *\n * @param {QueryOptions} options - Options for query execution.\n */\n matches(node, options = {}) {\n const startPosition = options.startPosition ?? ZERO_POINT;\n const endPosition = options.endPosition ?? ZERO_POINT;\n const startIndex = options.startIndex ?? 0;\n const endIndex = options.endIndex ?? 0;\n const matchLimit = options.matchLimit ?? 4294967295;\n const maxStartDepth = options.maxStartDepth ?? 4294967295;\n const timeoutMicros = options.timeoutMicros ?? 0;\n const progressCallback = options.progressCallback;\n if (typeof matchLimit !== \"number\") {\n throw new Error(\"Arguments must be numbers\");\n }\n this.matchLimit = matchLimit;\n if (endIndex !== 0 && startIndex > endIndex) {\n throw new Error(\"`startIndex` cannot be greater than `endIndex`\");\n }\n if (endPosition !== ZERO_POINT && (startPosition.row > endPosition.row || startPosition.row === endPosition.row && startPosition.column > endPosition.column)) {\n throw new Error(\"`startPosition` cannot be greater than `endPosition`\");\n }\n if (progressCallback) {\n C.currentQueryProgressCallback = progressCallback;\n }\n marshalNode(node);\n C._ts_query_matches_wasm(\n this[0],\n node.tree[0],\n startPosition.row,\n startPosition.column,\n endPosition.row,\n endPosition.column,\n startIndex,\n endIndex,\n matchLimit,\n maxStartDepth,\n timeoutMicros\n );\n const rawCount = C.getValue(TRANSFER_BUFFER, \"i32\");\n const startAddress = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const didExceedMatchLimit = C.getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, \"i32\");\n const result = new Array(rawCount);\n this.exceededMatchLimit = Boolean(didExceedMatchLimit);\n let filteredCount = 0;\n let address = startAddress;\n for (let i2 = 0; i2 < rawCount; i2++) {\n const patternIndex = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const captureCount = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const captures = new Array(captureCount);\n address = unmarshalCaptures(this, node.tree, address, patternIndex, captures);\n if (this.textPredicates[patternIndex].every((p) => p(captures))) {\n result[filteredCount] = { pattern: patternIndex, patternIndex, captures };\n const setProperties = this.setProperties[patternIndex];\n result[filteredCount].setProperties = setProperties;\n const assertedProperties = this.assertedProperties[patternIndex];\n result[filteredCount].assertedProperties = assertedProperties;\n const refutedProperties = this.refutedProperties[patternIndex];\n result[filteredCount].refutedProperties = refutedProperties;\n filteredCount++;\n }\n }\n result.length = filteredCount;\n C._free(startAddress);\n C.currentQueryProgressCallback = null;\n return result;\n }\n /**\n * Iterate over all of the individual captures in the order that they\n * appear.\n *\n * This is useful if you don't care about which pattern matched, and just\n * want a single, ordered sequence of captures.\n *\n * @param {Node} node - The node to execute the query on.\n *\n * @param {QueryOptions} options - Options for query execution.\n */\n captures(node, options = {}) {\n const startPosition = options.startPosition ?? ZERO_POINT;\n const endPosition = options.endPosition ?? ZERO_POINT;\n const startIndex = options.startIndex ?? 0;\n const endIndex = options.endIndex ?? 0;\n const matchLimit = options.matchLimit ?? 4294967295;\n const maxStartDepth = options.maxStartDepth ?? 4294967295;\n const timeoutMicros = options.timeoutMicros ?? 0;\n const progressCallback = options.progressCallback;\n if (typeof matchLimit !== \"number\") {\n throw new Error(\"Arguments must be numbers\");\n }\n this.matchLimit = matchLimit;\n if (endIndex !== 0 && startIndex > endIndex) {\n throw new Error(\"`startIndex` cannot be greater than `endIndex`\");\n }\n if (endPosition !== ZERO_POINT && (startPosition.row > endPosition.row || startPosition.row === endPosition.row && startPosition.column > endPosition.column)) {\n throw new Error(\"`startPosition` cannot be greater than `endPosition`\");\n }\n if (progressCallback) {\n C.currentQueryProgressCallback = progressCallback;\n }\n marshalNode(node);\n C._ts_query_captures_wasm(\n this[0],\n node.tree[0],\n startPosition.row,\n startPosition.column,\n endPosition.row,\n endPosition.column,\n startIndex,\n endIndex,\n matchLimit,\n maxStartDepth,\n timeoutMicros\n );\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const startAddress = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const didExceedMatchLimit = C.getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, \"i32\");\n const result = new Array();\n this.exceededMatchLimit = Boolean(didExceedMatchLimit);\n const captures = new Array();\n let address = startAddress;\n for (let i2 = 0; i2 < count; i2++) {\n const patternIndex = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const captureCount = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n const captureIndex = C.getValue(address, \"i32\");\n address += SIZE_OF_INT;\n captures.length = captureCount;\n address = unmarshalCaptures(this, node.tree, address, patternIndex, captures);\n if (this.textPredicates[patternIndex].every((p) => p(captures))) {\n const capture = captures[captureIndex];\n const setProperties = this.setProperties[patternIndex];\n capture.setProperties = setProperties;\n const assertedProperties = this.assertedProperties[patternIndex];\n capture.assertedProperties = assertedProperties;\n const refutedProperties = this.refutedProperties[patternIndex];\n capture.refutedProperties = refutedProperties;\n result.push(capture);\n }\n }\n C._free(startAddress);\n C.currentQueryProgressCallback = null;\n return result;\n }\n /** Get the predicates for a given pattern. */\n predicatesForPattern(patternIndex) {\n return this.predicates[patternIndex];\n }\n /**\n * Disable a certain capture within a query.\n *\n * This prevents the capture from being returned in matches, and also\n * avoids any resource usage associated with recording the capture.\n */\n disableCapture(captureName) {\n const captureNameLength = C.lengthBytesUTF8(captureName);\n const captureNameAddress = C._malloc(captureNameLength + 1);\n C.stringToUTF8(captureName, captureNameAddress, captureNameLength + 1);\n C._ts_query_disable_capture(this[0], captureNameAddress, captureNameLength);\n C._free(captureNameAddress);\n }\n /**\n * Disable a certain pattern within a query.\n *\n * This prevents the pattern from matching, and also avoids any resource\n * usage associated with the pattern. This throws an error if the pattern\n * index is out of bounds.\n */\n disablePattern(patternIndex) {\n if (patternIndex >= this.predicates.length) {\n throw new Error(\n `Pattern index is ${patternIndex} but the pattern count is ${this.predicates.length}`\n );\n }\n C._ts_query_disable_pattern(this[0], patternIndex);\n }\n /**\n * Check if, on its last execution, this cursor exceeded its maximum number\n * of in-progress matches.\n */\n didExceedMatchLimit() {\n return this.exceededMatchLimit;\n }\n /** Get the byte offset where the given pattern starts in the query's source. */\n startIndexForPattern(patternIndex) {\n if (patternIndex >= this.predicates.length) {\n throw new Error(\n `Pattern index is ${patternIndex} but the pattern count is ${this.predicates.length}`\n );\n }\n return C._ts_query_start_byte_for_pattern(this[0], patternIndex);\n }\n /** Get the byte offset where the given pattern ends in the query's source. */\n endIndexForPattern(patternIndex) {\n if (patternIndex >= this.predicates.length) {\n throw new Error(\n `Pattern index is ${patternIndex} but the pattern count is ${this.predicates.length}`\n );\n }\n return C._ts_query_end_byte_for_pattern(this[0], patternIndex);\n }\n /** Get the number of patterns in the query. */\n patternCount() {\n return C._ts_query_pattern_count(this[0]);\n }\n /** Get the index for a given capture name. */\n captureIndexForName(captureName) {\n return this.captureNames.indexOf(captureName);\n }\n /** Check if a given pattern within a query has a single root node. */\n isPatternRooted(patternIndex) {\n return C._ts_query_is_pattern_rooted(this[0], patternIndex) === 1;\n }\n /** Check if a given pattern within a query has a single root node. */\n isPatternNonLocal(patternIndex) {\n return C._ts_query_is_pattern_non_local(this[0], patternIndex) === 1;\n }\n /**\n * Check if a given step in a query is 'definite'.\n *\n * A query step is 'definite' if its parent pattern will be guaranteed to\n * match successfully once it reaches the step.\n */\n isPatternGuaranteedAtStep(byteIndex) {\n return C._ts_query_is_pattern_guaranteed_at_step(this[0], byteIndex) === 1;\n }\n};\n\n// src/language.ts\nvar LANGUAGE_FUNCTION_REGEX = /^tree_sitter_\\w+$/;\nvar Language = class _Language {\n static {\n __name(this, \"Language\");\n }\n /** @internal */\n [0] = 0;\n // Internal handle for WASM\n /**\n * A list of all node types in the language. The index of each type in this\n * array is its node type id.\n */\n types;\n /**\n * A list of all field names in the language. The index of each field name in\n * this array is its field id.\n */\n fields;\n /** @internal */\n constructor(internal, address) {\n assertInternal(internal);\n this[0] = address;\n this.types = new Array(C._ts_language_symbol_count(this[0]));\n for (let i2 = 0, n = this.types.length; i2 < n; i2++) {\n if (C._ts_language_symbol_type(this[0], i2) < 2) {\n this.types[i2] = C.UTF8ToString(C._ts_language_symbol_name(this[0], i2));\n }\n }\n this.fields = new Array(C._ts_language_field_count(this[0]) + 1);\n for (let i2 = 0, n = this.fields.length; i2 < n; i2++) {\n const fieldName = C._ts_language_field_name_for_id(this[0], i2);\n if (fieldName !== 0) {\n this.fields[i2] = C.UTF8ToString(fieldName);\n } else {\n this.fields[i2] = null;\n }\n }\n }\n /**\n * Gets the name of the language.\n */\n get name() {\n const ptr = C._ts_language_name(this[0]);\n if (ptr === 0) return null;\n return C.UTF8ToString(ptr);\n }\n /**\n * @deprecated since version 0.25.0, use {@link Language#abiVersion} instead\n * Gets the version of the language.\n */\n get version() {\n return C._ts_language_version(this[0]);\n }\n /**\n * Gets the ABI version of the language.\n */\n get abiVersion() {\n return C._ts_language_abi_version(this[0]);\n }\n /**\n * Get the metadata for this language. This information is generated by the\n * CLI, and relies on the language author providing the correct metadata in\n * the language's `tree-sitter.json` file.\n */\n get metadata() {\n C._ts_language_metadata(this[0]);\n const length = C.getValue(TRANSFER_BUFFER, \"i32\");\n const address = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n if (length === 0) return null;\n return unmarshalLanguageMetadata(address);\n }\n /**\n * Gets the number of fields in the language.\n */\n get fieldCount() {\n return this.fields.length - 1;\n }\n /**\n * Gets the number of states in the language.\n */\n get stateCount() {\n return C._ts_language_state_count(this[0]);\n }\n /**\n * Get the field id for a field name.\n */\n fieldIdForName(fieldName) {\n const result = this.fields.indexOf(fieldName);\n return result !== -1 ? result : null;\n }\n /**\n * Get the field name for a field id.\n */\n fieldNameForId(fieldId) {\n return this.fields[fieldId] ?? null;\n }\n /**\n * Get the node type id for a node type name.\n */\n idForNodeType(type, named) {\n const typeLength = C.lengthBytesUTF8(type);\n const typeAddress = C._malloc(typeLength + 1);\n C.stringToUTF8(type, typeAddress, typeLength + 1);\n const result = C._ts_language_symbol_for_name(this[0], typeAddress, typeLength, named ? 1 : 0);\n C._free(typeAddress);\n return result || null;\n }\n /**\n * Gets the number of node types in the language.\n */\n get nodeTypeCount() {\n return C._ts_language_symbol_count(this[0]);\n }\n /**\n * Get the node type name for a node type id.\n */\n nodeTypeForId(typeId) {\n const name2 = C._ts_language_symbol_name(this[0], typeId);\n return name2 ? C.UTF8ToString(name2) : null;\n }\n /**\n * Check if a node type is named.\n *\n * @see {@link https://tree-sitter.github.io/tree-sitter/using-parsers/2-basic-parsing.html#named-vs-anonymous-nodes}\n */\n nodeTypeIsNamed(typeId) {\n return C._ts_language_type_is_named_wasm(this[0], typeId) ? true : false;\n }\n /**\n * Check if a node type is visible.\n */\n nodeTypeIsVisible(typeId) {\n return C._ts_language_type_is_visible_wasm(this[0], typeId) ? true : false;\n }\n /**\n * Get the supertypes ids of this language.\n *\n * @see {@link https://tree-sitter.github.io/tree-sitter/using-parsers/6-static-node-types.html?highlight=supertype#supertype-nodes}\n */\n get supertypes() {\n C._ts_language_supertypes_wasm(this[0]);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const result = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n result[i2] = C.getValue(address, \"i16\");\n address += SIZE_OF_SHORT;\n }\n }\n return result;\n }\n /**\n * Get the subtype ids for a given supertype node id.\n */\n subtypes(supertype) {\n C._ts_language_subtypes_wasm(this[0], supertype);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const result = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n result[i2] = C.getValue(address, \"i16\");\n address += SIZE_OF_SHORT;\n }\n }\n return result;\n }\n /**\n * Get the next state id for a given state id and node type id.\n */\n nextState(stateId, typeId) {\n return C._ts_language_next_state(this[0], stateId, typeId);\n }\n /**\n * Create a new lookahead iterator for this language and parse state.\n *\n * This returns `null` if state is invalid for this language.\n *\n * Iterating {@link LookaheadIterator} will yield valid symbols in the given\n * parse state. Newly created lookahead iterators will return the `ERROR`\n * symbol from {@link LookaheadIterator#currentType}.\n *\n * Lookahead iterators can be useful for generating suggestions and improving\n * syntax error diagnostics. To get symbols valid in an `ERROR` node, use the\n * lookahead iterator on its first leaf node state. For `MISSING` nodes, a\n * lookahead iterator created on the previous non-extra leaf node may be\n * appropriate.\n */\n lookaheadIterator(stateId) {\n const address = C._ts_lookahead_iterator_new(this[0], stateId);\n if (address) return new LookaheadIterator(INTERNAL, address, this);\n return null;\n }\n /**\n * @deprecated since version 0.25.0, call `new` on a {@link Query} instead\n *\n * Create a new query from a string containing one or more S-expression\n * patterns.\n *\n * The query is associated with a particular language, and can only be run\n * on syntax nodes parsed with that language. References to Queries can be\n * shared between multiple threads.\n *\n * @link {@see https://tree-sitter.github.io/tree-sitter/using-parsers/queries}\n */\n query(source) {\n console.warn(\"Language.query is deprecated. Use new Query(language, source) instead.\");\n return new Query(this, source);\n }\n /**\n * Load a language from a WebAssembly module.\n * The module can be provided as a path to a file or as a buffer.\n */\n static async load(input) {\n let bytes;\n if (input instanceof Uint8Array) {\n bytes = Promise.resolve(input);\n } else {\n if (globalThis.process?.versions.node) {\n const fs2 = await import(\"fs/promises\");\n bytes = fs2.readFile(input);\n } else {\n bytes = fetch(input).then((response) => response.arrayBuffer().then((buffer) => {\n if (response.ok) {\n return new Uint8Array(buffer);\n } else {\n const body2 = new TextDecoder(\"utf-8\").decode(buffer);\n throw new Error(`Language.load failed with status ${response.status}.\n\n${body2}`);\n }\n }));\n }\n }\n const mod = await C.loadWebAssemblyModule(await bytes, { loadAsync: true });\n const symbolNames = Object.keys(mod);\n const functionName = symbolNames.find((key) => LANGUAGE_FUNCTION_REGEX.test(key) && !key.includes(\"external_scanner_\"));\n if (!functionName) {\n console.log(`Couldn't find language function in WASM file. Symbols:\n${JSON.stringify(symbolNames, null, 2)}`);\n throw new Error(\"Language.load failed: no language function found in WASM file\");\n }\n const languageAddress = mod[functionName]();\n return new _Language(INTERNAL, languageAddress);\n }\n};\n\n// src/bindings.ts\nvar import_tree_sitter = __toESM(require_tree_sitter(), 1);\nvar Module2 = null;\nasync function initializeBinding(moduleOptions) {\n if (!Module2) {\n Module2 = await (0, import_tree_sitter.default)(moduleOptions);\n }\n return Module2;\n}\n__name(initializeBinding, \"initializeBinding\");\nfunction checkModule() {\n return !!Module2;\n}\n__name(checkModule, \"checkModule\");\n\n// src/parser.ts\nvar TRANSFER_BUFFER;\nvar LANGUAGE_VERSION;\nvar MIN_COMPATIBLE_VERSION;\nvar Parser = class {\n static {\n __name(this, \"Parser\");\n }\n /** @internal */\n [0] = 0;\n // Internal handle for WASM\n /** @internal */\n [1] = 0;\n // Internal handle for WASM\n /** @internal */\n logCallback = null;\n /** The parser's current language. */\n language = null;\n /**\n * This must always be called before creating a Parser.\n *\n * You can optionally pass in options to configure the WASM module, the most common\n * one being `locateFile` to help the module find the `.wasm` file.\n */\n static async init(moduleOptions) {\n setModule(await initializeBinding(moduleOptions));\n TRANSFER_BUFFER = C._ts_init();\n LANGUAGE_VERSION = C.getValue(TRANSFER_BUFFER, \"i32\");\n MIN_COMPATIBLE_VERSION = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n }\n /**\n * Create a new parser.\n */\n constructor() {\n this.initialize();\n }\n /** @internal */\n initialize() {\n if (!checkModule()) {\n throw new Error(\"cannot construct a Parser before calling `init()`\");\n }\n C._ts_parser_new_wasm();\n this[0] = C.getValue(TRANSFER_BUFFER, \"i32\");\n this[1] = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n }\n /** Delete the parser, freeing its resources. */\n delete() {\n C._ts_parser_delete(this[0]);\n C._free(this[1]);\n this[0] = 0;\n this[1] = 0;\n }\n /**\n * Set the language that the parser should use for parsing.\n *\n * If the language was not successfully assigned, an error will be thrown.\n * This happens if the language was generated with an incompatible\n * version of the Tree-sitter CLI. Check the language's version using\n * {@link Language#version} and compare it to this library's\n * {@link LANGUAGE_VERSION} and {@link MIN_COMPATIBLE_VERSION} constants.\n */\n setLanguage(language) {\n let address;\n if (!language) {\n address = 0;\n this.language = null;\n } else if (language.constructor === Language) {\n address = language[0];\n const version = C._ts_language_version(address);\n if (version < MIN_COMPATIBLE_VERSION || LANGUAGE_VERSION < version) {\n throw new Error(\n `Incompatible language version ${version}. Compatibility range ${MIN_COMPATIBLE_VERSION} through ${LANGUAGE_VERSION}.`\n );\n }\n this.language = language;\n } else {\n throw new Error(\"Argument must be a Language\");\n }\n C._ts_parser_set_language(this[0], address);\n return this;\n }\n /**\n * Parse a slice of UTF8 text.\n *\n * @param {string | ParseCallback} callback - The UTF8-encoded text to parse or a callback function.\n *\n * @param {Tree | null} [oldTree] - A previous syntax tree parsed from the same document. If the text of the\n * document has changed since `oldTree` was created, then you must edit `oldTree` to match\n * the new text using {@link Tree#edit}.\n *\n * @param {ParseOptions} [options] - Options for parsing the text.\n * This can be used to set the included ranges, or a progress callback.\n *\n * @returns {Tree | null} A {@link Tree} if parsing succeeded, or `null` if:\n * - The parser has not yet had a language assigned with {@link Parser#setLanguage}.\n * - The progress callback returned true.\n */\n parse(callback, oldTree, options) {\n if (typeof callback === \"string\") {\n C.currentParseCallback = (index) => callback.slice(index);\n } else if (typeof callback === \"function\") {\n C.currentParseCallback = callback;\n } else {\n throw new Error(\"Argument must be a string or a function\");\n }\n if (options?.progressCallback) {\n C.currentProgressCallback = options.progressCallback;\n } else {\n C.currentProgressCallback = null;\n }\n if (this.logCallback) {\n C.currentLogCallback = this.logCallback;\n C._ts_parser_enable_logger_wasm(this[0], 1);\n } else {\n C.currentLogCallback = null;\n C._ts_parser_enable_logger_wasm(this[0], 0);\n }\n let rangeCount = 0;\n let rangeAddress = 0;\n if (options?.includedRanges) {\n rangeCount = options.includedRanges.length;\n rangeAddress = C._calloc(rangeCount, SIZE_OF_RANGE);\n let address = rangeAddress;\n for (let i2 = 0; i2 < rangeCount; i2++) {\n marshalRange(address, options.includedRanges[i2]);\n address += SIZE_OF_RANGE;\n }\n }\n const treeAddress = C._ts_parser_parse_wasm(\n this[0],\n this[1],\n oldTree ? oldTree[0] : 0,\n rangeAddress,\n rangeCount\n );\n if (!treeAddress) {\n C.currentParseCallback = null;\n C.currentLogCallback = null;\n C.currentProgressCallback = null;\n return null;\n }\n if (!this.language) {\n throw new Error(\"Parser must have a language to parse\");\n }\n const result = new Tree(INTERNAL, treeAddress, this.language, C.currentParseCallback);\n C.currentParseCallback = null;\n C.currentLogCallback = null;\n C.currentProgressCallback = null;\n return result;\n }\n /**\n * Instruct the parser to start the next parse from the beginning.\n *\n * If the parser previously failed because of a timeout, cancellation,\n * or callback, then by default, it will resume where it left off on the\n * next call to {@link Parser#parse} or other parsing functions.\n * If you don't want to resume, and instead intend to use this parser to\n * parse some other document, you must call `reset` first.\n */\n reset() {\n C._ts_parser_reset(this[0]);\n }\n /** Get the ranges of text that the parser will include when parsing. */\n getIncludedRanges() {\n C._ts_parser_included_ranges_wasm(this[0]);\n const count = C.getValue(TRANSFER_BUFFER, \"i32\");\n const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, \"i32\");\n const result = new Array(count);\n if (count > 0) {\n let address = buffer;\n for (let i2 = 0; i2 < count; i2++) {\n result[i2] = unmarshalRange(address);\n address += SIZE_OF_RANGE;\n }\n C._free(buffer);\n }\n return result;\n }\n /**\n * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}\n *\n * Get the duration in microseconds that parsing is allowed to take.\n *\n * This is set via {@link Parser#setTimeoutMicros}.\n */\n getTimeoutMicros() {\n return C._ts_parser_timeout_micros(this[0]);\n }\n /**\n * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}\n *\n * Set the maximum duration in microseconds that parsing should be allowed\n * to take before halting.\n *\n * If parsing takes longer than this, it will halt early, returning `null`.\n * See {@link Parser#parse} for more information.\n */\n setTimeoutMicros(timeout) {\n C._ts_parser_set_timeout_micros(this[0], 0, timeout);\n }\n /** Set the logging callback that a parser should use during parsing. */\n setLogger(callback) {\n if (!callback) {\n this.logCallback = null;\n } else if (typeof callback !== \"function\") {\n throw new Error(\"Logger callback must be a function\");\n } else {\n this.logCallback = callback;\n }\n return this;\n }\n /** Get the parser's current logger. */\n getLogger() {\n return this.logCallback;\n }\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n CaptureQuantifier,\n LANGUAGE_VERSION,\n Language,\n LookaheadIterator,\n MIN_COMPATIBLE_VERSION,\n Node,\n Parser,\n Query,\n Tree,\n TreeCursor\n});\n//# sourceMappingURL=tree-sitter.cjs.map\n","import { ComplexityHotspot, EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\n// Cyclomatic complexity: counts independent paths through a function.\n// Every decision point (if/loop/except/boolean operator/ternary) adds 1,\n// regardless of how deeply it is nested.\nexport function calculateCyclomaticComplexity(functionNode: any, language: LanguageAdapter): number {\n let complexity = 1; // Base complexity\n\n function countDecisionPoints(node: any, isRoot: boolean) {\n if (language.decisionNodeTypes.includes(node.type) || language.getBooleanOperator(node) !== null || language.isTryElseClause(node)) {\n complexity++;\n }\n\n // invariant: a nested named function/method's decision points are never counted toward the enclosing function's complexity — it is scored as its own separate violation by analyzeFunctionComplexity's traversal\n if (!isRoot && language.isFunctionDefinition(node)) {\n return;\n }\n\n for (const child of node.children) {\n countDecisionPoints(child, false);\n }\n }\n\n countDecisionPoints(functionNode, true);\n return complexity;\n}\n\n// Locates every decision point in a function and weights it by nesting\n// depth, so callers can render a per-line heatmap showing where the\n// complexity actually piles up (the metric itself stays flat/unweighted).\nexport function findCyclomaticHotspots(functionNode: any, positions: PositionLookup, language: LanguageAdapter): ComplexityHotspot[] {\n const hotspots: ComplexityHotspot[] = [];\n\n function walk(node: any, depth: number, isRoot: boolean) {\n let nextDepth = depth;\n if (language.decisionNodeTypes.includes(node.type) || language.getBooleanOperator(node) !== null || language.isTryElseClause(node)) {\n const line = positions.toPosition(node.startIndex).line;\n hotspots.push({ line, weight: 1 + depth });\n nextDepth = depth + 1;\n }\n\n // invariant: mirrors calculateCyclomaticComplexity's traversal exactly — a nested named function/method is hotspotted separately as its own violation, never folded into this one\n if (!isRoot && language.isFunctionDefinition(node)) {\n return;\n }\n\n for (const child of node.children) {\n walk(child, nextDepth, false);\n }\n }\n\n walk(functionNode, 0, true);\n return hotspots;\n}\n\nexport interface CyclomaticThresholds {\n mediumThreshold: number;\n highThreshold: number;\n}\n\nexport const DEFAULT_CYCLOMATIC_THRESHOLDS: CyclomaticThresholds = {\n mediumThreshold: 10,\n highThreshold: 15\n};\n\nexport function analyzeFunctionComplexity(\n tree: any,\n positions: PositionLookup,\n language: LanguageAdapter,\n thresholds: CyclomaticThresholds = DEFAULT_CYCLOMATIC_THRESHOLDS\n): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n\n function traverse(node: any) {\n if (language.isFunctionDefinition(node)) {\n const complexity = calculateCyclomaticComplexity(node, language);\n if (complexity > thresholds.mediumThreshold) {\n const position = positions.toPosition(node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.COMPLEXITY,\n severity: complexity > thresholds.highThreshold ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n message: `High cyclomatic complexity: ${complexity}. Consider breaking down this function.`,\n hotspots: findCyclomaticHotspots(node, positions, language)\n });\n }\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\nimport { findParametersNode } from './parameterCount';\n\ninterface TypedParam {\n name: string;\n type: string;\n node: any;\n}\n\n// Sub-check A (\"parameter swap risk\"): two adjacent parameters sharing the\n// same unqualified primitive type are indistinguishable at the call site —\n// nothing stops a caller passing them in the wrong order.\nfunction findParameterCollisions(paramsNode: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n const typed: TypedParam[] = paramsNode.children\n .map((n: any) => {\n const extracted = language.extractTypedParameter(n);\n return extracted ? { ...extracted, node: n } : null;\n })\n .filter((p: TypedParam | null): p is TypedParam => p !== null);\n\n for (let i = 0; i < typed.length - 1; i++) {\n const a = typed[i];\n const b = typed[i + 1];\n if (a.type === b.type && language.primitiveTypeNames.has(a.type)) {\n const position = positions.toPosition(a.node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.PRIMITIVE_OBSESSION,\n severity: SEVERITY.MEDIUM,\n message: `Primitive obsession: consecutive parameters '${a.name}: ${a.type}' and '${b.name}: ${b.type}' share the same primitive type — a caller can swap them and nothing will complain. Consider distinct types (NewType, dataclass) so the type checker catches it.`\n });\n }\n }\n return violations;\n}\n\nfunction stripQuotes(text: string): string {\n return text.slice(1, -1);\n}\n\n// Sub-check B (\"stringly-typed control flow\"): a variable repeatedly\n// compared against distinct string literals is a de facto enum encoded as\n// strings — no exhaustiveness checking, no typo protection at the type level.\n//\n// assumption: scoped to one function body at a time — the same variable name reused\n// across unrelated functions (e.g. two functions both naming a parameter `status`) does\n// not accumulate into a single false positive\nfunction findStringlyTypedControlFlow(functionNode: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n const { nodeTypes } = language;\n const valuesByVariable = new Map<string, Set<string>>();\n const firstOccurrence = new Map<string, any>();\n\n function isVariableRef(node: any): boolean {\n return language.variableReferenceNodeTypes.includes(node.type);\n }\n\n function record(varNode: any, values: string[]) {\n const key = varNode.text;\n if (!valuesByVariable.has(key)) {\n valuesByVariable.set(key, new Set());\n firstOccurrence.set(key, varNode);\n }\n const set = valuesByVariable.get(key)!;\n values.forEach(v => set.add(v));\n }\n\n function traverse(node: any) {\n for (const { left, right } of language.getEqualityComparisons(node)) {\n if (isVariableRef(left) && right.type === nodeTypes.stringLiteral) {\n record(left, [stripQuotes(right.text)]);\n } else if (isVariableRef(right) && left.type === nodeTypes.stringLiteral) {\n record(right, [stripQuotes(left.text)]);\n }\n }\n for (const { left, values } of language.getMembershipComparisons(node)) {\n if (isVariableRef(left) && values.length > 0) {\n record(left, values);\n }\n }\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(functionNode);\n\n const violations: EnergyViolation[] = [];\n for (const [key, values] of valuesByVariable) {\n if (values.size >= 3) {\n const node = firstOccurrence.get(key);\n const position = positions.toPosition(node.startIndex);\n const sample = Array.from(values).slice(0, 4);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.PRIMITIVE_OBSESSION,\n severity: SEVERITY.LOW,\n message: `Stringly-typed control flow: '${key}' is compared against ${values.size} distinct string literals (${sample.join(', ')}${values.size > sample.length ? ', …' : ''}). Consider an Enum or Literal type to catch typos and get exhaustiveness checking.`\n });\n }\n }\n return violations;\n}\n\n// The \"Primitive Obsession\" detector: strings and numbers standing in for\n// what should be a distinct, validated type. Both sub-checks are driven\n// entirely through LanguageAdapter hooks (extractTypedParameter,\n// primitiveTypeNames, getEqualityComparisons, getMembershipComparisons,\n// variableReferenceNodeTypes), so Python/TypeScript/F# all run the same\n// traversal logic below.\nexport function analyzePrimitiveObsession(tree: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n\n function traverse(node: any) {\n if (language.isFunctionDefinition(node)) {\n const paramsNode = findParametersNode(node, language.nodeTypes.parameters);\n if (paramsNode) {\n violations.push(...findParameterCollisions(paramsNode, positions, language));\n }\n violations.push(...findStringlyTypedControlFlow(node, positions, language));\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","#!/usr/bin/env node\n// Headless entry point: run the same detectors the extension uses, without\n// vscode, so an external process (e.g. an AI coding agent) can gate on\n// complexity without opening an editor.\n//\n// decision: exits 1 when any medium-or-high violation is found, not just high — CI/agent gating wants a single boolean signal, and severity is already visible in the emitted JSON for anyone who wants to discriminate further\nimport * as fs from 'fs';\nimport * as path from 'path';\nconst { Parser, Language } = require('web-tree-sitter');\n\nimport { analyzeSource } from './core/analyze';\nimport { DEFAULT_NESTING_THRESHOLDS } from './core/detectors/nesting';\nimport { resolveLanguageForFile } from './languages';\nimport { EnergyViolation, SEVERITY } from './types';\n\nfunction printUsage(): void {\n console.error('Usage: energy-state-cli <file.py|.fs|.fsx|.ts> [--medium-nesting N] [--high-nesting N] [--medium-cyclomatic N] [--high-cyclomatic N] [--medium-cognitive N] [--high-cognitive N]');\n}\n\nfunction parseArgs(argv: string[]) {\n const filePath = argv.find(arg => !arg.startsWith('--'));\n const flag = (name: string): number | undefined => {\n const index = argv.indexOf(`--${name}`);\n return index !== -1 ? Number(argv[index + 1]) : undefined;\n };\n\n return {\n filePath,\n nesting: {\n mediumThreshold: flag('medium-nesting'),\n highThreshold: flag('high-nesting')\n },\n cyclomatic: {\n mediumThreshold: flag('medium-cyclomatic'),\n highThreshold: flag('high-cyclomatic')\n },\n cognitive: {\n mediumThreshold: flag('medium-cognitive'),\n highThreshold: flag('high-cognitive')\n }\n };\n}\n\nasync function main(): Promise<void> {\n const { filePath, nesting, cyclomatic, cognitive } = parseArgs(process.argv.slice(2));\n\n if (!filePath) {\n printUsage();\n process.exit(2);\n }\n\n const adapter = resolveLanguageForFile(filePath);\n if (!adapter) {\n console.error(`Unsupported file type: ${filePath}`);\n printUsage();\n process.exit(2);\n }\n\n const sourceCode = fs.readFileSync(filePath, 'utf8');\n\n await Parser.init();\n const parser = new Parser();\n const grammarPath = path.join(__dirname, '..', adapter.grammarPath);\n const grammar = await Language.load(grammarPath);\n parser.setLanguage(grammar);\n\n const tree = parser.parse(sourceCode);\n const violations: EnergyViolation[] = analyzeSource(sourceCode, tree, adapter, filePath, {\n nesting: nesting.mediumThreshold !== undefined || nesting.highThreshold !== undefined\n ? {\n mediumThreshold: nesting.mediumThreshold ?? DEFAULT_NESTING_THRESHOLDS.mediumThreshold,\n highThreshold: nesting.highThreshold ?? DEFAULT_NESTING_THRESHOLDS.highThreshold\n }\n : undefined,\n cyclomatic: cyclomatic.mediumThreshold !== undefined || cyclomatic.highThreshold !== undefined\n ? { mediumThreshold: cyclomatic.mediumThreshold ?? 10, highThreshold: cyclomatic.highThreshold ?? 15 }\n : undefined,\n cognitive: cognitive.mediumThreshold !== undefined || cognitive.highThreshold !== undefined\n ? { mediumThreshold: cognitive.mediumThreshold ?? 15, highThreshold: cognitive.highThreshold ?? 25 }\n : undefined\n });\n\n console.log(JSON.stringify(violations, null, 2));\n\n const hasBlockingViolation = violations.some(v => v.severity === SEVERITY.HIGH || v.severity === SEVERITY.MEDIUM);\n process.exit(hasBlockingViolation ? 1 : 0);\n}\n\nmain().catch(error => {\n console.error('energy-state-cli failed:', error);\n process.exit(1);\n});\n","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\nexport interface NestingThresholds {\n mediumThreshold: number;\n highThreshold: number;\n}\n\n// decision: default medium threshold of 3 is the point where tracking active conditions starts to strain working memory; high threshold of 5 escalates severity for the deepest offenders\nexport const DEFAULT_NESTING_THRESHOLDS: NestingThresholds = {\n mediumThreshold: 3,\n highThreshold: 5\n};\n\nexport function analyzeNesting(\n tree: any,\n positions: PositionLookup,\n language: LanguageAdapter,\n thresholds: NestingThresholds = DEFAULT_NESTING_THRESHOLDS\n): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n\n function traverse(node: any, depth: number = 0) {\n if (language.nestingControlTypes.includes(node.type)) {\n if (depth > thresholds.mediumThreshold) {\n const position = positions.toPosition(node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.NESTING,\n severity: depth > thresholds.highThreshold ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n message: `Excessive nesting depth: ${depth}. Consider extracting.`\n });\n }\n depth++;\n }\n\n for (const child of node.children) {\n traverse(child, depth);\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","import { LanguageAdapter } from '../core/language';\n\n// tree-sitter-typescript is structurally close to Python's grammar: real\n// block/body nodes, a distinct else_clause, and and/or (&&/||) each get\n// their own node type as the operator-token child of a binary_expression.\n//\n// decision: treats arrow functions (`(x) => x + 1`) as `lambda`, matching Python's `lambda` — they add structural nesting in cognitive complexity but aren't analyzed by parameter-count/complexity/coherence themselves (same limitation Python already has for its own lambdas); only named `function_declaration`s and class `method_definition`s count as \"a function\" for those detectors\n//\n// tradeoff: accepts a slightly higher cognitive-complexity score for `else if` chains (else_clause's flat +1 plus the nested if's `1 + nesting`) instead of unwrapping single-if else-clauses specially — TypeScript's `else if` parses as `else_clause` wrapping a nested `if_statement`, unlike Python's flat elif sibling\nexport const TYPESCRIPT: LanguageAdapter = {\n id: 'typescript',\n grammarPath: 'grammars/tree-sitter-typescript.wasm',\n nodeTypes: {\n block: 'statement_block',\n parameters: 'formal_parameters',\n ifStatement: 'if_statement',\n elseClause: 'else_clause',\n forStatement: 'for_statement',\n whileStatement: 'while_statement',\n conditionalExpression: 'ternary_expression',\n lambda: 'arrow_function',\n importStatement: 'import_statement',\n importFromStatement: null, // import_statement already covers every import form\n expressionStatement: 'expression_statement',\n assignment: 'lexical_declaration',\n module: 'program',\n exportStatement: 'export_statement',\n comment: 'comment',\n integerLiteral: 'number', // TS doesn't distinguish int/float, both are \"number\"\n floatLiteral: null,\n stringLiteral: 'string'\n },\n isFunctionDefinition(node: any): boolean {\n return node?.type === 'function_declaration' || node?.type === 'method_definition';\n },\n parameterChildTypes: ['required_parameter', 'optional_parameter'],\n decisionNodeTypes: [\n 'if_statement', 'for_statement', 'for_in_statement', 'while_statement',\n 'catch_clause', 'ternary_expression'\n ],\n cognitiveNestedDecisionTypes: [\n 'if_statement', 'for_statement', 'for_in_statement', 'while_statement', 'catch_clause'\n ],\n nestingControlTypes: ['if_statement', 'for_statement', 'for_in_statement', 'while_statement'],\n getBooleanOperator(node: any): 'and' | 'or' | null {\n if (!node || node.type !== 'binary_expression') {\n return null;\n }\n const opToken = node.children?.find((c: any) => c.type === '&&' || c.type === '||');\n if (!opToken) {\n return null;\n }\n return opToken.type === '&&' ? 'and' : 'or';\n },\n entersNestedScope(node: any): boolean {\n return node?.type === 'statement_block';\n },\n // JS/TS try/catch has no else-branch construct.\n isTryElseClause(): boolean {\n return false;\n },\n variableReferenceNodeTypes: ['identifier', 'member_expression'],\n extractTypedParameter(node: any): { name: string; type: string } | null {\n if (node?.type !== 'required_parameter' && node?.type !== 'optional_parameter') {\n return null;\n }\n const nameNode = node.children.find((c: any) => c.type === 'identifier');\n const typeAnnotation = node.children.find((c: any) => c.type === 'type_annotation');\n if (!nameNode || !typeAnnotation) {\n return null;\n }\n // type_annotation's children are [':', <the actual type node>]\n const typeNode = typeAnnotation.children.find((c: any) => c.type !== ':');\n if (!typeNode) {\n return null;\n }\n return { name: nameNode.text, type: typeNode.text };\n },\n primitiveTypeNames: new Set(['string', 'number', 'boolean']),\n getEqualityComparisons(node: any): Array<{ left: any; right: any }> {\n if (node?.type !== 'binary_expression') {\n return [];\n }\n const opToken = node.children.find((c: any) => c.type === '===' || c.type === '==');\n if (!opToken) {\n return [];\n }\n const operands = node.children.filter((c: any) => c !== opToken);\n if (operands.length !== 2) {\n return [];\n }\n return [{ left: operands[0], right: operands[1] }];\n },\n // TS's set-membership idiom is `[...].includes(x)`, a call_expression rather than a\n // comparison node — not modeled here; repeated equality checks still accumulate via\n // getEqualityComparisons.\n getMembershipComparisons(): Array<{ left: any; values: string[] }> {\n return [];\n },\n // `else if` has no flat elif node in this grammar — it's a nested if_statement one\n // level inside else_clause, which the match-opportunity detector walks itself.\n getElseIfBranches(): any[] {\n return [];\n }\n};\n","// Offset-to-line/column conversion that doesn't depend on vscode.TextDocument,\n// so detectors can run both inside the extension and in a headless CLI.\n//\n// decision: binary-searches precomputed line-start offsets instead of using vscode.TextDocument.positionAt — keeps detectors host-independent (see cli.ts)\n\nexport interface Position {\n line: number;\n column: number;\n}\n\nexport interface PositionLookup {\n toPosition(offset: number): Position;\n}\n\nexport function createPositionLookup(sourceText: string): PositionLookup {\n const lineStartOffsets: number[] = [0];\n for (let i = 0; i < sourceText.length; i++) {\n if (sourceText[i] === '\\n') {\n lineStartOffsets.push(i + 1);\n }\n }\n\n return {\n toPosition(offset: number): Position {\n let low = 0;\n let high = lineStartOffsets.length - 1;\n while (low < high) {\n const mid = Math.ceil((low + high) / 2);\n if (lineStartOffsets[mid] <= offset) {\n low = mid;\n } else {\n high = mid - 1;\n }\n }\n return { line: low, column: offset - lineStartOffsets[low] };\n }\n };\n}\n","// Shared types for energy violation detectors (cyclomatic.ts, cognitive.ts, extension.ts)\n\nexport const SEVERITY = {\n LOW: 'low' as const,\n MEDIUM: 'medium' as const,\n HIGH: 'high' as const\n};\n\nexport const VIOLATION_TYPE = {\n NESTING: 'nesting' as const,\n COMPLEXITY: 'complexity' as const,\n COGNITIVE: 'cognitive' as const,\n NAMING: 'naming' as const,\n COHERENCE: 'coherence' as const,\n MAGIC: 'magic' as const,\n PARAMETERS: 'parameters' as const,\n INVERSION: 'inversion' as const,\n PRIMITIVE_OBSESSION: 'primitive-obsession' as const,\n MATCH_OPPORTUNITY: 'match-opportunity' as const,\n LOGICAL_CONTROL_FLOW: 'logical-control-flow' as const\n};\n\n// decision: reports per-line weighted hotspots (nesting depth for cognitive, decision density for cyclomatic) alongside the flat complexity score — lets callers paint a progressive heatmap across the function body instead of a single flat highlight, so the worst lines stand out visually\nexport interface ComplexityHotspot {\n line: number;\n weight: number;\n}\n\nexport interface EnergyViolation {\n line: number;\n column: number;\n type: 'nesting' | 'complexity' | 'cognitive' | 'naming' | 'coherence' | 'magic' | 'parameters' | 'inversion' | 'primitive-obsession' | 'match-opportunity' | 'logical-control-flow';\n severity: 'low' | 'medium' | 'high';\n message: string;\n hotspots?: ComplexityHotspot[];\n}\n","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\n// decision: does a level-by-level (breadth-first) search rather than a depth-first one — finds a function's own parameters node even when nested a level below the function node itself (e.g. F#'s argument_patterns sits inside function_declaration_left), while still stopping before it can reach a nested function's parameters\n// shared with primitiveObsession.ts's parameter-swap-risk check — same structural problem, same fix\nexport function findParametersNode(node: any, parametersType: string): any {\n for (const child of node.children) {\n if (child.type === parametersType) {\n return child;\n }\n }\n for (const child of node.children) {\n const found = findParametersNode(child, parametersType);\n if (found) {\n return found;\n }\n }\n return undefined;\n}\n\n// The \"Parameter Explosion\" detector\nexport function analyzeParameterCount(tree: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n\n function traverse(node: any) {\n if (language.isFunctionDefinition(node)) {\n const params = findParametersNode(node, language.nodeTypes.parameters);\n if (params) {\n const paramCount = params.children.filter((child: any) =>\n language.parameterChildTypes.includes(child.type)\n ).length;\n\n // decision: flags past 5 parameters (medium) and 8 (high) — beyond ~5, callers typically can no longer recall argument order/meaning without checking the signature\n if (paramCount > 5) {\n const position = positions.toPosition(node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.PARAMETERS,\n severity: paramCount > 8 ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n message: `Parameter explosion: ${paramCount} parameters. Consider using objects or builder pattern.`\n });\n }\n }\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\n// The \"Logical Operator as Control Flow\" detector: flags `condition && doSomething();` (or\n// `condition || fallback();`) used as a standalone statement.\n//\n// decision: this is legal in every language the LanguageAdapter grammar reports an\n// expressionStatement for (Python's bare `and`/`or` expression statement included, not just\n// TS/JS's `&&`/`||`) and it already counts toward cyclomatic complexity via\n// getBooleanOperator (see cyclomatic.ts) — this detector exists only to name the *readability*\n// cost separately: an if hidden as an expression is invisible to anyone skimming for branches,\n// and can't grow past a single consequent expression without becoming unreadable.\nexport function analyzeLogicalControlFlow(tree: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n const { nodeTypes } = language;\n\n function traverse(node: any) {\n const operator = language.getBooleanOperator(node);\n if (operator !== null && node.parent?.type === nodeTypes.expressionStatement) {\n const position = positions.toPosition(node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.LOGICAL_CONTROL_FLOW,\n severity: SEVERITY.LOW,\n message: operator === 'and'\n ? \"If-statement disguised as '&&'. Consider an explicit if-statement instead.\"\n : \"If-statement disguised as '||'. Consider an explicit if-statement instead.\"\n });\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { LanguageAdapter } from '../language';\n\nexport interface CoherenceThresholds {\n // decision: gates file-coherence sprawl detection on large-function count, not raw function count — languages like F# idiomatically have many small functions per module, so what matters is functions large enough to carry real complexity\n largeFunctionLines: number;\n // Number of large functions (per largeFunctionLines) a file can contain\n // before it's flagged.\n maxLargeFunctions: number;\n}\n\nexport const DEFAULT_COHERENCE_THRESHOLDS: CoherenceThresholds = {\n largeFunctionLines: 20,\n maxLargeFunctions: 5\n};\n\nfunction lineCount(node: any): number {\n return node.endPosition.row - node.startPosition.row + 1;\n}\n\n// The \"Utils/Helpers Sprawl\" detector - detects files losing coherence\nexport function analyzeFileCoherence(\n tree: any,\n fileName: string,\n language: LanguageAdapter,\n thresholds: CoherenceThresholds = DEFAULT_COHERENCE_THRESHOLDS\n): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n const functions: any[] = [];\n const imports: string[] = [];\n const { nodeTypes } = language;\n\n function traverse(node: any) {\n if (language.isFunctionDefinition(node)) {\n functions.push(node);\n } else if (node.type === nodeTypes.importStatement || node.type === nodeTypes.importFromStatement) {\n imports.push(node.text || '');\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(tree.rootNode);\n\n const largeFunctions = functions.filter(fn => lineCount(fn) > thresholds.largeFunctionLines);\n\n // Flag files with too many unrelated functions (utils/helpers sprawl)\n // decision: lowers the flagging threshold from 12 to 8 functions when the filename itself signals a grab-bag module (util/helper/common) — the name is treated as a proxy for \"already known to lack a single responsibility\"\n if (functions.length > 8) {\n const baseName = fileName.split('/').pop() || '';\n const isUtilsFile = baseName.includes('util') || baseName.includes('helper') || baseName.includes('common');\n\n if (isUtilsFile || functions.length > 12) {\n violations.push({\n line: 0,\n column: 0,\n type: VIOLATION_TYPE.COHERENCE,\n severity: functions.length > 15 ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n message: `File coherence warning: ${functions.length} functions in one file. Consider splitting by domain.`\n });\n }\n }\n\n // Flag files with too many large functions, regardless of total function\n // count - a module with 30 small functions is fine, one with 6 sprawling\n // ones isn't.\n if (largeFunctions.length > thresholds.maxLargeFunctions) {\n violations.push({\n line: 0,\n column: 0,\n type: VIOLATION_TYPE.COHERENCE,\n severity: largeFunctions.length > thresholds.maxLargeFunctions * 1.5 ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n message: `${largeFunctions.length} functions exceed ${thresholds.largeFunctionLines} lines. Large functions carry more complexity than function count alone suggests.`\n });\n }\n\n // Flag excessive imports (another sign of incoherence)\n if (imports.length > 10) {\n violations.push({\n line: 0,\n column: 0,\n type: VIOLATION_TYPE.COHERENCE,\n severity: imports.length > 15 ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n message: `Import sprawl: ${imports.length} imports suggest this file does too much.`\n });\n }\n\n return violations;\n}\n","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\nexport interface MatchOpportunityThresholds {\n minBranches: number;\n}\n\nexport const DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS: MatchOpportunityThresholds = {\n minBranches: 3\n};\n\nfunction stripQuotes(text: string): string {\n return text.slice(1, -1);\n}\n\n// Walks an if-statement/if-expression node and returns every branch in the\n// same chain, in source order: the node itself, then either its flat elif\n// siblings (Python/F#, via getElseIfBranches) or — when there are none — the\n// chain of `else if`-nested if-statements (TypeScript's shape, where each\n// continuation sits one level inside an else_clause).\nfunction collectChainBranches(ifNode: any, language: LanguageAdapter): any[] {\n const branches = [ifNode];\n\n const flatSiblings = language.getElseIfBranches(ifNode);\n if (flatSiblings.length > 0) {\n branches.push(...flatSiblings);\n return branches;\n }\n\n let current = ifNode;\n while (true) {\n const elseClause = current.children?.find((c: any) => c.type === language.nodeTypes.elseClause);\n if (!elseClause) break;\n const nestedIf = elseClause.children?.find((c: any) => c.type === language.nodeTypes.ifStatement);\n if (!nestedIf) break;\n branches.push(nestedIf);\n current = nestedIf;\n }\n return branches;\n}\n\n// Collects every {variable, literal value} pair a single branch's own\n// condition/guard compares, without wandering into its consequence body or\n// into the next branch in the chain.\n//\n// decision: stops recursion at nodeTypes.block/elseClause and at any other\n// branch of the same chain, rather than resolving \"the condition\" via a\n// grammar-specific field name — this project's LanguageAdapter otherwise\n// avoids per-grammar field lookups (see language.ts), and a bounded scan\n// keeps that consistent at the cost of also scanning a branch's own\n// consequence when a grammar has no block wrapper (F#), matching the same\n// whole-subtree-scan tradeoff already accepted by primitiveObsession.ts\nfunction collectBranchDiscriminants(branchNode: any, otherBranches: Set<any>, language: LanguageAdapter): Array<{ variable: string; value: string }> {\n const { nodeTypes } = language;\n const found: Array<{ variable: string; value: string }> = [];\n\n function isVariableRef(node: any): boolean {\n return language.variableReferenceNodeTypes.includes(node.type);\n }\n\n function isLiteral(node: any): boolean {\n return node.type === nodeTypes.stringLiteral || node.type === nodeTypes.integerLiteral || node.type === nodeTypes.floatLiteral;\n }\n\n function literalValue(node: any): string {\n return node.type === nodeTypes.stringLiteral ? stripQuotes(node.text) : node.text;\n }\n\n function walk(node: any) {\n if (otherBranches.has(node) || node.type === nodeTypes.block || node.type === nodeTypes.elseClause) {\n return;\n }\n\n for (const { left, right } of language.getEqualityComparisons(node)) {\n if (isVariableRef(left) && isLiteral(right)) {\n found.push({ variable: left.text, value: literalValue(right) });\n } else if (isVariableRef(right) && isLiteral(left)) {\n found.push({ variable: right.text, value: literalValue(left) });\n }\n }\n for (const { left, values } of language.getMembershipComparisons(node)) {\n if (isVariableRef(left)) {\n values.forEach(value => found.push({ variable: left.text, value }));\n }\n }\n\n for (const child of node.children || []) {\n walk(child);\n }\n }\n\n walk(branchNode);\n return found;\n}\n\n// The \"Match Opportunity\" detector: an if/elif/elif chain (or TS's nested\n// `else if`) with enough branches, all discriminating on equality/membership\n// checks against the same single variable, is a natural fit for Python's\n// `match`, TypeScript's `switch`, or F#'s `match` — those give exhaustiveness\n// hints and one comparison site instead of N.\n//\n// decision: requires every branch to carry its own literal comparison against\n// the same variable — a chain with an unconditional catch-all `else` still\n// qualifies (the else itself contributes no discriminant and isn't a\n// \"branch\" for this check), but a chain mixing unrelated conditions across\n// branches does not, since match/switch can't express that dispatch anyway\nexport function analyzeMatchOpportunities(\n tree: any,\n positions: PositionLookup,\n language: LanguageAdapter,\n thresholds: MatchOpportunityThresholds = DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS\n): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n const { nodeTypes } = language;\n const consumed = new Set<any>();\n\n function traverse(node: any) {\n if (node.type === nodeTypes.ifStatement && !consumed.has(node)) {\n analyzeChain(node);\n }\n\n for (const child of node.children || []) {\n traverse(child);\n }\n }\n\n function analyzeChain(topIfNode: any) {\n const branches = collectChainBranches(topIfNode, language);\n branches.slice(1).forEach(branch => consumed.add(branch));\n\n if (branches.length < thresholds.minBranches) {\n return;\n }\n\n const perBranchDiscriminants = branches.map(branch =>\n collectBranchDiscriminants(branch, new Set(branches.filter(b => b !== branch)), language)\n );\n\n if (perBranchDiscriminants.some(discriminants => discriminants.length === 0)) {\n return;\n }\n\n const candidateVariables = perBranchDiscriminants[0].map(d => d.variable);\n const commonVariable = candidateVariables.find(variable =>\n perBranchDiscriminants.every(discriminants => discriminants.some(d => d.variable === variable))\n );\n if (!commonVariable) {\n return;\n }\n\n const position = positions.toPosition(topIfNode.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.MATCH_OPPORTUNITY,\n severity: SEVERITY.LOW,\n message: `This ${branches.length}-way if/elif chain all branch on '${commonVariable}'. Consider a match/switch statement for clearer, exhaustiveness-checked dispatch.`\n });\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","module.exports = require(\"fs\");","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\n// The \"Inversion Opportunity\" detector - finds patterns that could benefit from early returns\nexport function analyzeInversionOpportunities(tree: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n const { nodeTypes } = language;\n\n function traverse(node: any) {\n if (language.isFunctionDefinition(node)) {\n analyzeFunction(node);\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n function analyzeFunction(functionNode: any) {\n // Find the function body\n const body = functionNode.children.find((child: any) => child.type === nodeTypes.block);\n if (!body) return;\n\n // Look for patterns that could benefit from inversion\n //\n // decision: filters on isNamed, not just a non-comment/non-blank text check - grammars\n // with an explicit block wrapper (e.g. TS's statement_block) include the literal '{'/'}'\n // tokens in .children, and those pass a text?.trim() check same as a real statement would.\n // Without this, `statements[0]` on such grammars is always the '{' token, never the\n // function's actual first statement, so Pattern 1 below can never match.\n const statements = body.children.filter((child: any) =>\n child.isNamed && child.type !== nodeTypes.comment && child.text?.trim()\n );\n\n // Pattern 1: Single large if-statement dominating the function\n if (statements.length >= 1) {\n const firstStatement = statements[0];\n if (firstStatement.type === nodeTypes.ifStatement) {\n const ifBody = firstStatement.children.find((child: any) => child.type === nodeTypes.block);\n if (ifBody && ifBody.children.length > 2) {\n // Check if this if-statement contains most of the function logic\n const totalLines = functionNode.endIndex - functionNode.startIndex;\n const ifLines = ifBody.endIndex - ifBody.startIndex;\n const ratio = ifLines / totalLines;\n\n // decision: flags only when the if-body spans more than half the function — below that, the if is a fragment rather than the function's dominant structure\n if (ratio > 0.5) {\n const position = positions.toPosition(firstStatement.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.INVERSION,\n severity: SEVERITY.MEDIUM,\n message: 'Consider inverting this condition and using early return for cleaner flow.'\n });\n }\n }\n }\n }\n\n // Pattern 2: Nested validation checks that could be guard clauses\n analyzeNestedValidation(body);\n\n // Pattern 3: Multiple nested if-statements that could be flattened\n analyzeNestedIfs(body);\n }\n\n function analyzeNestedValidation(body: any) {\n // Look for patterns like: if (valid) { if (moreValid) { if (evenMoreValid) { ... } } }\n // decision: caps the validation-chain walk at 4 levels — deep chains beyond that are already caught by analyzeNestedIfs, so this loop only needs to bound its own work\n let currentNode = body;\n let nestingLevel = 0;\n const validationChecks: any[] = [];\n\n while (currentNode && nestingLevel < 4) {\n const statements = currentNode.children?.filter((child: any) =>\n child.type === nodeTypes.ifStatement || child.type === nodeTypes.forStatement || child.type === nodeTypes.whileStatement\n ) || [];\n\n if (statements.length === 1 && statements[0].type === nodeTypes.ifStatement) {\n const ifStatement = statements[0];\n validationChecks.push(ifStatement);\n\n // Check if this looks like a validation (no else clause, simple condition)\n const hasElse = ifStatement.children.some((child: any) => child.type === nodeTypes.elseClause);\n if (!hasElse) {\n const ifBody = ifStatement.children.find((child: any) => child.type === nodeTypes.block);\n currentNode = ifBody;\n nestingLevel++;\n } else {\n break;\n }\n } else {\n break;\n }\n }\n\n // decision: suggests guard clauses starting at 2 chained validation checks — a single nested if is normal control flow, not yet a pattern worth restructuring\n if (validationChecks.length >= 2) {\n const firstCheck = validationChecks[0];\n const position = positions.toPosition(firstCheck.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.INVERSION,\n severity: SEVERITY.MEDIUM,\n message: `Found ${validationChecks.length} nested validation checks. Consider using guard clauses with early returns.`\n });\n }\n }\n\n function analyzeNestedIfs(body: any) {\n // Count deeply nested if statements that could be flattened\n let maxNesting = 0;\n let nestedIfLocation: any = null;\n\n function countNesting(node: any, currentDepth: number = 0) {\n if (node.type === nodeTypes.ifStatement) {\n if (currentDepth > maxNesting) {\n maxNesting = currentDepth;\n nestedIfLocation = node;\n }\n currentDepth++;\n }\n\n for (const child of node.children || []) {\n countNesting(child, currentDepth);\n }\n }\n\n countNesting(body);\n\n // decision: flags if-nesting at 3+ levels here, one level below analyzeNesting's depth>3 threshold — this detector targets flattenable if-chains specifically, so it can fire earlier than the general nesting detector\n if (maxNesting >= 3 && nestedIfLocation) {\n const position = positions.toPosition(nestedIfLocation.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.INVERSION,\n severity: SEVERITY.MEDIUM,\n message: `Deep if-nesting (${maxNesting} levels). Consider inverting conditions or extracting functions.`\n });\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","import { LanguageAdapter } from '../core/language';\nimport { PYTHON } from './python';\nimport { FSHARP } from './fsharp';\nimport { TYPESCRIPT } from './typescript';\n\n// decision: keys LANGUAGES by vscode languageId rather than file extension — the extension host already resolves languageId, and resolveLanguageForFile below provides the file-extension equivalent for the CLI\nexport const LANGUAGES: Record<string, LanguageAdapter> = {\n python: PYTHON,\n fsharp: FSHARP,\n typescript: TYPESCRIPT\n};\n\nconst EXTENSION_TO_LANGUAGE_ID: Record<string, string> = {\n '.py': 'python',\n '.fs': 'fsharp',\n '.fsx': 'fsharp',\n '.fsi': 'fsharp',\n '.ts': 'typescript'\n};\n\nexport function resolveLanguageForFile(fileName: string): LanguageAdapter | undefined {\n const dotIndex = fileName.lastIndexOf('.');\n if (dotIndex === -1) {\n return undefined;\n }\n const extension = fileName.slice(dotIndex).toLowerCase();\n const languageId = EXTENSION_TO_LANGUAGE_ID[extension];\n return languageId ? LANGUAGES[languageId] : undefined;\n}\n","module.exports = require(\"path\");","module.exports = require(\"fs/promises\");","import { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\nexport interface MagicValuesOptions {\n enabled: boolean;\n}\n\nexport const DEFAULT_MAGIC_VALUES_OPTIONS: MagicValuesOptions = { enabled: true };\n\n// The \"Magic Numbers/Strings\" detector\nexport function analyzeMagicValues(\n tree: any,\n positions: PositionLookup,\n language: LanguageAdapter,\n options: MagicValuesOptions = DEFAULT_MAGIC_VALUES_OPTIONS\n): EnergyViolation[] {\n const violations: EnergyViolation[] = [];\n if (!options.enabled) {\n return violations;\n }\n const { nodeTypes } = language;\n\n function isDocstring(node: any): boolean {\n // decision: treats any standalone string statement as documentation, not a value — covers module/function/class docstrings and PEP 257-style attribute docstrings following a field (e.g. `code: int` then `\"\"\"...\"\"\"`)\n return node.parent?.type === nodeTypes.expressionStatement;\n }\n\n function isInConstantContext(node: any): boolean {\n // decision: uses a heuristic (assignment at module level, optionally wrapped in `export`) rather than resolving actual scope — cheap to check per-node and sufficient because idiomatic module-level constants are the common case this is meant to exempt\n let parent = node.parent;\n while (parent) {\n if (parent.type === nodeTypes.assignment) {\n // decision: F# has no separate node type for \"function definition\" vs \"plain\n // value binding\" (both are function_or_value_defn), so a literal deep inside a\n // function's body would otherwise match this ancestor and be wrongly treated as\n // the function's own \"named constant\" value. Once the nearest assignment-shaped\n // ancestor is actually a function, the literal is computed logic, not a binding.\n if (language.isFunctionDefinition(parent)) {\n return false;\n }\n const grandparent = parent.parent;\n if (grandparent?.type === nodeTypes.module) {\n return true;\n }\n if (nodeTypes.exportStatement && grandparent?.type === nodeTypes.exportStatement\n && grandparent.parent?.type === nodeTypes.module) {\n return true;\n }\n }\n parent = parent.parent;\n }\n return false;\n }\n\n function traverse(node: any) {\n // Flag suspicious numeric literals\n if (node.type === nodeTypes.integerLiteral || node.type === nodeTypes.floatLiteral) {\n const value = parseInt(node.text) || parseFloat(node.text);\n // decision: exempts 0, 1, 100, and 1000 from magic-number flagging — these appear constantly as loop bounds, percentages, and unit conversions without carrying hidden meaning worth naming\n const isSignificant = value > 1 && value !== 100 && value !== 1000; // Allow common values\n\n if (isSignificant && !isInConstantContext(node)) {\n const position = positions.toPosition(node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.MAGIC,\n severity: SEVERITY.LOW,\n message: `Magic number: ${node.text}. Consider extracting to a named constant.`\n });\n }\n }\n\n // Flag suspicious string literals (potential config/messages)\n if (node.type === nodeTypes.stringLiteral && node.text.length > 15 && !isDocstring(node)) {\n const content = node.text.slice(1, -1); // Remove quotes\n // assumption: a string containing a space plus one of \"error\"/\"invalid\"/\"not found\" is a user-facing message worth extracting — narrow on purpose to avoid flagging arbitrary prose strings\n const looksLikeMessage = content.includes(' ') && (content.includes('error') || content.includes('invalid') || content.includes('not found'));\n\n if (looksLikeMessage) {\n const position = positions.toPosition(node.startIndex);\n violations.push({\n line: position.line,\n column: position.column,\n type: VIOLATION_TYPE.MAGIC,\n severity: SEVERITY.LOW,\n message: `Magic string: Consider extracting error messages to constants.`\n });\n }\n }\n\n for (const child of node.children) {\n traverse(child);\n }\n }\n\n traverse(tree.rootNode);\n return violations;\n}\n","import { EnergyViolation } from '../types';\nimport { createPositionLookup } from './position';\nimport { LanguageAdapter } from './language';\nimport { analyzeNesting, NestingThresholds, DEFAULT_NESTING_THRESHOLDS } from './detectors/nesting';\nimport { analyzeFunctionComplexity, CyclomaticThresholds, DEFAULT_CYCLOMATIC_THRESHOLDS } from './detectors/cyclomatic';\nimport { analyzeCognitiveComplexity, CognitiveThresholds, DEFAULT_COGNITIVE_THRESHOLDS } from './detectors/cognitive';\nimport { analyzeFileCoherence, CoherenceThresholds, DEFAULT_COHERENCE_THRESHOLDS } from './detectors/coherence';\nimport { analyzeMagicValues, MagicValuesOptions, DEFAULT_MAGIC_VALUES_OPTIONS } from './detectors/magicValues';\nimport { analyzeParameterCount } from './detectors/parameterCount';\nimport { analyzeInversionOpportunities } from './detectors/inversion';\nimport { analyzePrimitiveObsession } from './detectors/primitiveObsession';\nimport { analyzeMatchOpportunities, MatchOpportunityThresholds, DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS } from './detectors/matchOpportunity';\nimport { analyzeLogicalControlFlow } from './detectors/logicalControlFlow';\n\nexport interface AnalyzeThresholds {\n nesting?: NestingThresholds;\n cyclomatic?: CyclomaticThresholds;\n cognitive?: CognitiveThresholds;\n coherence?: CoherenceThresholds;\n matchOpportunity?: MatchOpportunityThresholds;\n magicValues?: MagicValuesOptions;\n}\n\n// Language-agnostic entry point: runs every detector over an already-parsed\n// tree-sitter tree.\n//\n// decision: runs every detector unconditionally except where a detector exposes its own\n// enabled flag (currently only magicValues) — a caller-selected subset would let the\n// extension and the CLI (cli.ts) drift on which violations exist for the same file, but a\n// per-detector on/off default that both entry points inherit identically does not\n// reintroduce that drift\n// invariant: this module and everything it calls must not import vscode — used by both the VS Code extension (per keystroke) and the headless CLI (per file)\nexport function analyzeSource(\n sourceText: string,\n tree: any,\n language: LanguageAdapter,\n fileName: string,\n thresholds: AnalyzeThresholds = {}\n): EnergyViolation[] {\n const positions = createPositionLookup(sourceText);\n const violations: EnergyViolation[] = [];\n\n violations.push(...analyzeNesting(tree, positions, language, thresholds.nesting ?? DEFAULT_NESTING_THRESHOLDS));\n violations.push(...analyzeFunctionComplexity(tree, positions, language, thresholds.cyclomatic ?? DEFAULT_CYCLOMATIC_THRESHOLDS));\n violations.push(...analyzeCognitiveComplexity(tree, positions, language, thresholds.cognitive ?? DEFAULT_COGNITIVE_THRESHOLDS));\n violations.push(...analyzeFileCoherence(tree, fileName, language, thresholds.coherence ?? DEFAULT_COHERENCE_THRESHOLDS));\n violations.push(...analyzeMagicValues(tree, positions, language, thresholds.magicValues ?? DEFAULT_MAGIC_VALUES_OPTIONS));\n violations.push(...analyzeParameterCount(tree, positions, language));\n violations.push(...analyzeInversionOpportunities(tree, positions, language));\n violations.push(...analyzePrimitiveObsession(tree, positions, language));\n violations.push(...analyzeMatchOpportunities(tree, positions, language, thresholds.matchOpportunity ?? DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS));\n violations.push(...analyzeLogicalControlFlow(tree, positions, language));\n\n return violations;\n}\n","import { LanguageAdapter } from '../core/language';\n\n// tree-sitter-fsharp has no block/body wrapper node — an if/for/while's\n// branches are direct expression children of the construct itself (there's\n// no equivalent of Python's `block` or TypeScript's `statement_block`), and\n// `else` isn't a distinct node type either (an else-if chain is just a\n// nested if_expression in the `else` position). Boolean operators (&&/||)\n// aren't their own node type: they're an `infix_expression` whose `infix_op`\n// child's text happens to be \"&&\" or \"||\", same shape as `+`/`-`/etc.\n//\n// decision: checks for a function_declaration_left child in isFunctionDefinition rather than matching function_or_value_defn alone — that node type also covers plain `let`/`let!` bindings (via value_declaration_left), and without the check every nested `let`/`let!` inside a function body (e.g. inside a MailboxProcessor `actor { let! msg = ... }`) would be misidentified as its own nested closure\n// invariant: a nested let/let! binding never inflates the enclosing function's cognitive complexity or nesting depth — only bindings with a function_declaration_left child count as a function\n//\n// assumption: any literal that is the direct value of a `let` binding (top-level or nested) is already named and not flagged as a magic value — broader than Python's module-only rule, since function_or_value_defn -> declaration_expression looks identical at every scope, but still aligned with the detector's intent that `let NAME = ...` IS F#'s idiomatic way to name a constant\nexport const FSHARP: LanguageAdapter = {\n id: 'fsharp',\n grammarPath: 'grammars/tree-sitter-fsharp.wasm',\n nodeTypes: {\n block: null,\n parameters: 'argument_patterns',\n ifStatement: 'if_expression',\n elseClause: null,\n forStatement: 'for_expression',\n whileStatement: 'while_expression',\n conditionalExpression: null, // ternary-position `if` reuses if_expression, already covered\n lambda: 'fun_expression',\n importStatement: 'import_decl', // `open X`\n importFromStatement: null,\n expressionStatement: null, // F# has no string-literal docstring convention\n assignment: 'function_or_value_defn',\n module: 'declaration_expression',\n exportStatement: null,\n comment: 'line_comment',\n integerLiteral: 'int',\n floatLiteral: 'float',\n stringLiteral: 'string'\n },\n isFunctionDefinition(node: any): boolean {\n return node?.type === 'function_or_value_defn'\n && node.children?.some((child: any) => child.type === 'function_declaration_left');\n },\n parameterChildTypes: ['long_identifier', 'typed_pattern'],\n decisionNodeTypes: [\n 'if_expression', 'elif_expression', 'for_expression', 'while_expression',\n 'try_expression', 'match_expression'\n ],\n cognitiveNestedDecisionTypes: [\n 'if_expression', 'elif_expression', 'for_expression', 'while_expression',\n 'try_expression', 'match_expression'\n ],\n nestingControlTypes: ['if_expression', 'elif_expression', 'for_expression', 'while_expression', 'match_expression'],\n getBooleanOperator(node: any): 'and' | 'or' | null {\n if (!node || node.type !== 'infix_expression') {\n return null;\n }\n const opToken = node.children?.find((c: any) => c.type === 'infix_op');\n if (opToken?.text === '&&') {\n return 'and';\n }\n if (opToken?.text === '||') {\n return 'or';\n }\n return null;\n },\n // No block wrapper exists, so every child of a decision point is nested content.\n entersNestedScope(): boolean {\n return true;\n },\n // F#'s try_expression has no else-branch construct.\n isTryElseClause(): boolean {\n return false;\n },\n // long_identifier_or_op's own .text is already the bare (possibly dotted) name, so\n // it's used as-is rather than unwrapped down to a leaf identifier.\n variableReferenceNodeTypes: ['long_identifier_or_op'],\n extractTypedParameter(node: any): { name: string; type: string } | null {\n if (node?.type !== 'typed_pattern') {\n return null;\n }\n const patternNode = node.children.find((c: any) => c.type === 'identifier_pattern');\n const typeNode = node.children.find((c: any) => c.type === 'simple_type');\n if (!patternNode || !typeNode) {\n return null;\n }\n return { name: patternNode.text, type: typeNode.text };\n },\n primitiveTypeNames: new Set(['string', 'int', 'float', 'bool']),\n getEqualityComparisons(node: any): Array<{ left: any; right: any }> {\n if (node?.type !== 'infix_expression') {\n return [];\n }\n const opToken = node.children.find((c: any) => c.type === 'infix_op');\n if (!opToken || opToken.text !== '=') {\n return [];\n }\n const operands = node.children.filter((c: any) => c.type !== 'infix_op');\n if (operands.length !== 2) {\n return [];\n }\n const [left, rawRight] = operands;\n // Literals are wrapped in a `const` node; unwrap so callers can compare\n // .type against nodeTypes.stringLiteral directly, same as Python/TS.\n const right = (rawRight.type === 'const' && rawRight.children?.length === 1)\n ? rawRight.children[0]\n : rawRight;\n return [{ left, right }];\n },\n // F# has no `x in (a, b, c)`-style membership construct; repeated equality checks\n // (e.g. an elif chain) still accumulate via getEqualityComparisons.\n getMembershipComparisons(): Array<{ left: any; values: string[] }> {\n return [];\n },\n getElseIfBranches(node: any): any[] {\n return node?.children?.filter((c: any) => c.type === 'elif_expression') ?? [];\n }\n};\n","import { LanguageAdapter } from '../core/language';\n\nexport const PYTHON: LanguageAdapter = {\n id: 'python',\n grammarPath: 'grammars/tree-sitter-python.wasm',\n nodeTypes: {\n block: 'block',\n parameters: 'parameters',\n ifStatement: 'if_statement',\n elseClause: 'else_clause',\n forStatement: 'for_statement',\n whileStatement: 'while_statement',\n conditionalExpression: 'conditional_expression',\n lambda: 'lambda',\n importStatement: 'import_statement',\n importFromStatement: 'import_from_statement',\n expressionStatement: 'expression_statement',\n assignment: 'assignment',\n module: 'module',\n exportStatement: null,\n comment: 'comment',\n integerLiteral: 'integer',\n floatLiteral: 'float',\n stringLiteral: 'string'\n },\n isFunctionDefinition(node: any): boolean {\n return node?.type === 'function_definition';\n },\n parameterChildTypes: ['identifier', 'default_parameter'],\n decisionNodeTypes: [\n 'if_statement', 'elif_clause', 'while_statement', 'for_statement',\n 'except_clause', 'conditional_expression', 'match_statement'\n ],\n cognitiveNestedDecisionTypes: [\n 'if_statement', 'elif_clause', 'for_statement', 'while_statement', 'except_clause', 'match_statement'\n ],\n nestingControlTypes: ['if_statement', 'for_statement', 'while_statement', 'with_statement', 'match_statement'],\n getBooleanOperator(node: any): 'and' | 'or' | null {\n if (!node || node.type !== 'boolean_operator') {\n return null;\n }\n const opToken = node.children?.find((c: any) => c.type === 'and' || c.type === 'or');\n return opToken ? (opToken.type as 'and' | 'or') : null;\n },\n entersNestedScope(node: any): boolean {\n return node?.type === 'block';\n },\n // decision: `else_clause` is shared by if/for/while/try in tree-sitter-python, but only a\n // try's else is a real decision point (mirrors ruff's C901: a non-vacuous try-else adds 1).\n // if/for/while's else already scores 0 via decisionNodeTypes, matching how plain `else`\n // (as opposed to `elif`) is excluded there — this predicate exists to avoid conflating\n // try's else with those.\n isTryElseClause(node: any): boolean {\n return node?.type === 'else_clause' && node?.parent?.type === 'try_statement';\n },\n variableReferenceNodeTypes: ['identifier', 'attribute'],\n extractTypedParameter(node: any): { name: string; type: string } | null {\n if (node?.type !== 'typed_parameter' && node?.type !== 'typed_default_parameter') {\n return null;\n }\n const nameNode = node.children.find((c: any) => c.type === 'identifier');\n const typeNode = node.children.find((c: any) => c.type === 'type');\n if (!nameNode || !typeNode) {\n return null;\n }\n return { name: nameNode.text, type: typeNode.text };\n },\n primitiveTypeNames: new Set(['str', 'int', 'float', 'bool', 'bytes']),\n getEqualityComparisons(node: any): Array<{ left: any; right: any }> {\n if (node?.type !== 'comparison_operator') {\n return [];\n }\n const results: Array<{ left: any; right: any }> = [];\n const children = node.children;\n for (let i = 1; i < children.length - 1; i++) {\n if (children[i].type === '==') {\n results.push({ left: children[i - 1], right: children[i + 1] });\n }\n }\n return results;\n },\n // decision: only Python gets this — TS's equivalent is a `.includes()` call expression\n // (not a comparison node) and F# has no direct construct; both still accumulate distinct\n // literals across separate equality comparisons via getEqualityComparisons.\n getMembershipComparisons(node: any): Array<{ left: any; values: string[] }> {\n if (node?.type !== 'comparison_operator') {\n return [];\n }\n const results: Array<{ left: any; values: string[] }> = [];\n const children = node.children;\n for (let i = 1; i < children.length - 1; i++) {\n if (children[i].type !== 'in') {\n continue;\n }\n const left = children[i - 1];\n const right = children[i + 1];\n if (right.type !== 'tuple' && right.type !== 'list' && right.type !== 'set') {\n continue;\n }\n const values: string[] = [];\n let allStrings = true;\n for (const child of right.children) {\n if (!child.isNamed) {\n continue;\n }\n if (child.type !== 'string') {\n allStrings = false;\n break;\n }\n values.push(child.text.slice(1, -1));\n }\n if (allStrings && values.length > 0) {\n results.push({ left, values });\n }\n }\n return results;\n },\n getElseIfBranches(node: any): any[] {\n return node?.children?.filter((c: any) => c.type === 'elif_clause') ?? [];\n }\n};\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(186);\n"],"names":["calculateCognitiveComplexity","functionNode","language","onContribution","score","nodeTypes","add","node","amount","walkNested","nesting","child","children","walk","entersNestedScope","booleanOperator","getBooleanOperator","parent","cognitiveNestedDecisionTypes","includes","type","elseClause","conditionalExpression","isFunctionDefinition","lambda","findCognitiveHotspots","positions","hotspots","push","line","toPosition","startIndex","weight","DEFAULT_COGNITIVE_THRESHOLDS","mediumThreshold","highThreshold","tree","thresholds","violations","traverse","complexity","position","column","VIOLATION_TYPE","COGNITIVE","severity","SEVERITY","HIGH","MEDIUM","message","rootNode","__create","Object","create","__defProp","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__getProtoOf","getPrototypeOf","__hasOwnProp","prototype","hasOwnProperty","__name","target","value","configurable","__commonJS","cb","mod","exports","__export","all","name2","get","enumerable","__copyProps","to","from","except","desc","key","call","__toESM","isNodeMode","__esModule","__toCommonJS","require_tree_sitter","module","Module","_scriptName","document","currentScript","src","__filename","async","moduleArg","moduleRtn","readyPromiseResolve","readyPromiseReject","readyPromise","Promise","resolve","reject","ENVIRONMENT_IS_WEB","window","ENVIRONMENT_IS_WORKER","WorkerGlobalScope","ENVIRONMENT_IS_NODE","process","versions","ENVIRONMENT_IS_SHELL","currentQueryProgressCallback","currentProgressCallback","currentLogCallback","currentParseCallback","moduleOverrides","assign","arguments_","thisProgram","quit_","status","toThrow","scriptDirectory","readAsync","readBinary","locateFile","path","fs","nodePath","__dirname","filename","isFileURI","URL","readFileSync","binary2","argv","length","replace","slice","exitCode","self","location","href","startsWith","lastIndexOf","url","xhr","XMLHttpRequest","open","responseType","send","Uint8Array","response","onload","onerror","fetch","credentials","ok","arrayBuffer","Error","out","console","log","bind","err","error","dynamicLibraries","wasmBinary","wasmMemory","ABORT","EXITSTATUS","HEAP","HEAP8","HEAPU8","HEAP16","HEAPU16","HEAP32","HEAPU32","HEAPF32","HEAP64","HEAPU64","HEAPF64","HEAP_DATA_VIEW","assert","condition","text","abort","runtimeInitialized","updateMemoryViews","b","buffer","DataView","Int8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","BigInt64Array","BigUint64Array","INITIAL_MEMORY","WebAssembly","Memory","__RELOC_FUNCS__","preRun","addOnPreRun","shift","callRuntimeCallbacks","onPreRuns","initRuntime","wasmExports","onPostCtors","preMain","postRun","addOnPostRun","onPostRuns","runDependencies","dependenciesFulfilled","wasmBinaryFile","getUniqueRunDependency","id","addRunDependency","removeRunDependency","callback","what","e","RuntimeError","findWasmBinary","getBinarySync","file","getWasmBinary","binaryFile","instantiateArrayBuffer","imports","instantiate","reason","instantiateAsync","instantiateStreaming","getWasmImports","wasmImports","Proxy","GOTHandler","createWasm","receiveInstance","instance2","module2","relocateExports","metadata2","getDylinkMetadata","neededDynlibs","concat","mergeLibSymbols","LDSO","init","loadDylibs","receiveInstantiationResult","result2","info2","inst","ASM_CONSTS","ExitStatus","this","name","constructor","GOT","currentModuleWeakSymbols","Set","obj","symName","rtn","Global","has","required","LE_HEAP_LOAD_F32","byteOffset","getFloat32","LE_HEAP_LOAD_F64","getFloat64","LE_HEAP_LOAD_I16","getInt16","LE_HEAP_LOAD_I32","getInt32","LE_HEAP_LOAD_U16","getUint16","LE_HEAP_LOAD_U32","getUint32","LE_HEAP_STORE_F32","setFloat32","LE_HEAP_STORE_F64","setFloat64","LE_HEAP_STORE_I16","setInt16","LE_HEAP_STORE_I32","setInt32","LE_HEAP_STORE_U16","setUint16","LE_HEAP_STORE_U32","setUint32","callbacks","unshift","UTF8Decoder","TextDecoder","UTF8ArrayToString","heapOrArray","idx","maxBytesToRead","NaN","endIdx","endPtr","decode","subarray","str","u0","u1","u2","String","fromCharCode","ch","offset","end","getU8","getLEB","ret","mul","byte","getString","len","failIf","dylinkSection","customSections","int32View","section_size","customSection","tlsExports","weakImports","memorySize","memoryAlign","tableSize","tableAlign","neededDynlibsCount","i2","libname","subsectionType","subsectionSize","count","symname","getValue","ptr","endsWith","newDSO","handle2","syms","dso","refcount","Infinity","global","loadedLibsByName","loadedLibsByHandle","___heap_base","alignMemory","size","alignment","Math","ceil","getMemory","_calloc","isInternalSym","uleb128Encode","n","sigToWasmTypes","sig","typeNames","parameters","results","generateFuncType","sigRet","sigParam","typeCodes","convertJsFunctionToWasm","func2","Function","typeSectionBody","bytes","Instance","wasmTableMirror","wasmTable","Table","getWasmTableEntry","funcPtr","updateTableMap","functionsInTableMap","item","set","getFunctionAddress","WeakMap","freeTableIndexes","getEmptyTableSlot","pop","grow","err2","RangeError","setWasmTableEntry","addFunction","TypeError","wrapped","updateGOT","exports2","memoryBase2","relocated","isSymbolDefined","existing","stub","dynCall","args2","stackSave","_emscripten_stack_get_current","stackRestore","val","__emscripten_stack_restore","createInvokeFunction","sp","_setThrew","resolveGlobalSymbol","direct","sym","split","addOnPostCtor","UTF8ToString","loadWebAssemblyModule","binary","flags","libName","localScope","handle","metadata","loadModule","memAlign","pow","memoryBase","tableBase","moduleExports","resolveSymbol","resolved","proxyHandler","stubs","prop","proxy","info","postInstantiation","instance","addEmAsm","addr","body","args","arity","indexOf","join","func","start","eval","allowUndefined","reportUndefinedSymbols","stop","jsString","addEmJs","cSig","jsArgs","i","jsArg","parts","applyRelocs","loadAsync","then","result","reduce","chain","dynNeeded","loadDynamicLibrary","forEach","needed","libName2","exp","entries","setImport","main_alias","asyncLoad","flags2","nodelete","localScope2","loadLibData","data","dataSize","libData","libFile","getExports","moduleLoaded","entry","lib","noExitRuntime","setValue","BigInt","___memory_base","___stack_pointer","___table_base","__abort_js","_emscripten_get_now","performance","now","_emscripten_date_now","Date","nowIsMonotonic","checkWasiClock","clock_id","INT53_MAX","INT53_MIN","bigintToI53Checked","num","Number","_clock_time_get","clk_id","ignored_precision","ptime","nsec","round","getHeapMax","growMemory","pages","byteLength","_emscripten_resize_heap","requestedSize","oldSize","maxHeapSize","cutDown","overGrownHeapSize","min","newSize","max","_fd_close","fd","_fd_seek","whence","newOffset","printCharBuffers","printChar","stream","curr","flush_NO_FILESYSTEM","SYSCALLS","varargs","getStr","_fd_write","iov","iovcnt","pnum","j","_tree_sitter_log_callback","isLexMessage","messageAddress","_tree_sitter_parse_callback","inputBufferAddress","index","row","lengthAddress","string","stringToUTF16","_tree_sitter_progress_callback","currentOffset","hasError","_tree_sitter_query_progress_callback","runtimeKeepaliveCounter","keepRuntimeAlive","_proc_exit","code","exitJS","implicit","handleException","lengthBytesUTF8","c","charCodeAt","stringToUTF8Array","heap","outIdx","maxBytesToWrite","startIdx","u","stringToUTF8","outPtr","stackAlloc","sz","__emscripten_stack_alloc","stringToUTF8OnStack","AsciiToString","startPtr","numCharsToWrite","codeUnit","__heap_base","__indirect_function_table","__memory_base","__stack_pointer","__table_base","_abort_js","clock_time_get","emscripten_resize_heap","fd_close","fd_seek","fd_write","memory","tree_sitter_log_callback","tree_sitter_parse_callback","tree_sitter_progress_callback","tree_sitter_query_progress_callback","___wasm_call_ctors","_malloc","_realloc","_free","_memcmp","_ts_language_symbol_count","_ts_language_state_count","_ts_language_version","_ts_language_abi_version","_ts_language_metadata","_ts_language_name","_ts_language_field_count","_ts_language_next_state","_ts_language_symbol_name","_ts_language_symbol_for_name","_strncmp","_ts_language_symbol_type","_ts_language_field_name_for_id","_ts_lookahead_iterator_new","_ts_lookahead_iterator_delete","_ts_lookahead_iterator_reset_state","_ts_lookahead_iterator_reset","_ts_lookahead_iterator_next","_ts_lookahead_iterator_current_symbol","_ts_parser_delete","_ts_parser_reset","_ts_parser_set_language","_ts_parser_timeout_micros","_ts_parser_set_timeout_micros","_ts_parser_set_included_ranges","_ts_query_new","_ts_query_delete","_iswspace","_iswalnum","_ts_query_pattern_count","_ts_query_capture_count","_ts_query_string_count","_ts_query_capture_name_for_id","_ts_query_capture_quantifier_for_id","_ts_query_string_value_for_id","_ts_query_predicates_for_pattern","_ts_query_start_byte_for_pattern","_ts_query_end_byte_for_pattern","_ts_query_is_pattern_rooted","_ts_query_is_pattern_non_local","_ts_query_is_pattern_guaranteed_at_step","_ts_query_disable_capture","_ts_query_disable_pattern","_ts_tree_copy","_ts_tree_delete","_ts_init","_ts_parser_new_wasm","_ts_parser_enable_logger_wasm","_ts_parser_parse_wasm","_ts_parser_included_ranges_wasm","_ts_language_type_is_named_wasm","_ts_language_type_is_visible_wasm","_ts_language_supertypes_wasm","_ts_language_subtypes_wasm","_ts_tree_root_node_wasm","_ts_tree_root_node_with_offset_wasm","_ts_tree_edit_wasm","_ts_tree_included_ranges_wasm","_ts_tree_get_changed_ranges_wasm","_ts_tree_cursor_new_wasm","_ts_tree_cursor_copy_wasm","_ts_tree_cursor_delete_wasm","_ts_tree_cursor_reset_wasm","_ts_tree_cursor_reset_to_wasm","_ts_tree_cursor_goto_first_child_wasm","_ts_tree_cursor_goto_last_child_wasm","_ts_tree_cursor_goto_first_child_for_index_wasm","_ts_tree_cursor_goto_first_child_for_position_wasm","_ts_tree_cursor_goto_next_sibling_wasm","_ts_tree_cursor_goto_previous_sibling_wasm","_ts_tree_cursor_goto_descendant_wasm","_ts_tree_cursor_goto_parent_wasm","_ts_tree_cursor_current_node_type_id_wasm","_ts_tree_cursor_current_node_state_id_wasm","_ts_tree_cursor_current_node_is_named_wasm","_ts_tree_cursor_current_node_is_missing_wasm","_ts_tree_cursor_current_node_id_wasm","_ts_tree_cursor_start_position_wasm","_ts_tree_cursor_end_position_wasm","_ts_tree_cursor_start_index_wasm","_ts_tree_cursor_end_index_wasm","_ts_tree_cursor_current_field_id_wasm","_ts_tree_cursor_current_depth_wasm","_ts_tree_cursor_current_descendant_index_wasm","_ts_tree_cursor_current_node_wasm","_ts_node_symbol_wasm","_ts_node_field_name_for_child_wasm","_ts_node_field_name_for_named_child_wasm","_ts_node_children_by_field_id_wasm","_ts_node_first_child_for_byte_wasm","_ts_node_first_named_child_for_byte_wasm","_ts_node_grammar_symbol_wasm","_ts_node_child_count_wasm","_ts_node_named_child_count_wasm","_ts_node_child_wasm","_ts_node_named_child_wasm","_ts_node_child_by_field_id_wasm","_ts_node_next_sibling_wasm","_ts_node_prev_sibling_wasm","_ts_node_next_named_sibling_wasm","_ts_node_prev_named_sibling_wasm","_ts_node_descendant_count_wasm","_ts_node_parent_wasm","_ts_node_child_with_descendant_wasm","_ts_node_descendant_for_index_wasm","_ts_node_named_descendant_for_index_wasm","_ts_node_descendant_for_position_wasm","_ts_node_named_descendant_for_position_wasm","_ts_node_start_point_wasm","_ts_node_end_point_wasm","_ts_node_start_index_wasm","_ts_node_end_index_wasm","_ts_node_to_string_wasm","_ts_node_children_wasm","_ts_node_named_children_wasm","_ts_node_descendants_of_type_wasm","_ts_node_is_named_wasm","_ts_node_has_changes_wasm","_ts_node_has_error_wasm","_ts_node_is_error_wasm","_ts_node_is_missing_wasm","_ts_node_is_extra_wasm","_ts_node_parse_state_wasm","_ts_node_next_parse_state_wasm","_ts_query_matches_wasm","_ts_query_captures_wasm","_memset","_memcpy","_memmove","_iswalpha","_iswblank","_iswdigit","_iswlower","_iswupper","_iswxdigit","_memchr","_strlen","_strcmp","_strncat","_strncpy","_towlower","_towupper","___wasm_apply_data_relocs","callMain","entryFunction","argc","argv_ptr","arg","run","doRun","setTimeout","default","index_exports","CaptureQuantifier","LANGUAGE_VERSION","Language","LookaheadIterator","MIN_COMPATIBLE_VERSION","Node","Parser","Query","Tree","TreeCursor","SIZE_OF_SHORT","SIZE_OF_INT","SIZE_OF_CURSOR","SIZE_OF_NODE","SIZE_OF_POINT","SIZE_OF_RANGE","ZERO_POINT","INTERNAL","Symbol","C","assertInternal","x","isPoint","point","setModule","internal","address","currentTypeId","currentType","types","reset","stateId","resetState","Boolean","iterator","next","done","getText","endIndex","startPosition","textCallback","_Tree","copy","unmarshalNode","rootNodeWithOffset","offsetBytes","offsetExtent","TRANSFER_BUFFER","marshalPoint","edit","marshalEdit","getChangedRanges","other","Array","unmarshalRange","getIncludedRanges","_TreeCursor","unmarshalTreeCursor","marshalTreeCursor","currentNode","currentFieldId","currentFieldName","fields","currentDepth","currentDescendantIndex","nodeType","nodeTypeId","nodeStateId","nodeId","nodeIsNamed","nodeIsMissing","nodeText","unmarshalPoint","endPosition","gotoFirstChild","gotoLastChild","gotoParent","gotoNextSibling","gotoPreviousSibling","gotoDescendant","goalDescendantIndex","gotoFirstChildForIndex","goalIndex","gotoFirstChildForPosition","goalPosition","marshalNode","resetTo","cursor","_children","_namedChildren","typeId","grammarId","grammarType","isNamed","isExtra","isError","isMissing","hasChanges","parseState","nextParseState","equals","namedChild","childForFieldId","fieldId","childForFieldName","fieldName","fieldNameForChild","fieldNameForNamedChild","childrenForFieldName","childrenForFieldId","firstChildForIndex","firstNamedChildForIndex","childCount","namedChildCount","firstChild","firstNamedChild","lastChild","lastNamedChild","namedChildren","descendantsOfType","isArray","symbols","typesBySymbol","node_type","symbolsAddress","descendantCount","descendantAddress","nextSibling","previousSibling","nextNamedSibling","previousNamedSibling","childWithDescendant","descendant","descendantForIndex","start2","namedDescendantForIndex","descendantForPosition","namedDescendantForPosition","oldEndIndex","subbedPointRow","subbedPointColumn","newEndIndex","oldEndPosition","newEndPosition","toString","unmarshalCaptures","query","patternIndex","captureIndex","captureNames","marshalRange","range","unmarshalLanguageMetadata","major_version","minor_version","field_count","PREDICATE_STEP_TYPE_CAPTURE","PREDICATE_STEP_TYPE_STRING","QUERY_WORD_REGEX","Zero","ZeroOrOne","ZeroOrMore","One","OneOrMore","isCaptureStep","step","isStringStep","QueryErrorKind","Syntax","NodeName","FieldName","CaptureName","PatternStructure","QueryError","_QueryError","kind","super","formatMessage","word","suffix","parseAnyPredicate","steps","operator","textPredicates","isPositive","matchAll","captureName1","captureName2","captures","nodes1","nodes2","compare","n1","n2","positive","every","some","captureName","stringValue","matches","doesNotMatch","nodes","test","parseMatchPredicate","regex","RegExp","parseAnyOfPredicate","stringSteps","values","map","s","parseIsPredicate","assertedProperties","refutedProperties","properties","parseSetDirective","setProperties","parsePattern","stepType","stepValueId","stringValues","predicates","operands","exceededMatchLimit","captureQuantifiers","matchLimit","source","sourceLength","sourceAddress","errorId","errorByte","errorIndex","match","stringCount","captureCount","patternCount","nameAddress","nameLength","captureQuantifiersArray","quantifier","valueAddress","predicatesAddress","stepCount","stepAddress","freeze","options","maxStartDepth","timeoutMicros","progressCallback","rawCount","startAddress","didExceedMatchLimit","filteredCount","p","pattern","capture","predicatesForPattern","disableCapture","captureNameLength","captureNameAddress","disablePattern","startIndexForPattern","endIndexForPattern","captureIndexForName","isPatternRooted","isPatternNonLocal","isPatternGuaranteedAtStep","byteIndex","LANGUAGE_FUNCTION_REGEX","_Language","version","abiVersion","fieldCount","stateCount","fieldIdForName","fieldNameForId","idForNodeType","named","typeLength","typeAddress","nodeTypeCount","nodeTypeForId","nodeTypeIsNamed","nodeTypeIsVisible","supertypes","subtypes","supertype","nextState","lookaheadIterator","warn","load","input","globalThis","readFile","body2","symbolNames","keys","functionName","find","JSON","stringify","languageAddress","import_tree_sitter","Module2","initializeBinding","moduleOptions","checkModule","logCallback","initialize","setLanguage","parse","oldTree","rangeCount","rangeAddress","includedRanges","treeAddress","getTimeoutMicros","setTimeoutMicros","timeout","setLogger","getLogger","calculateCyclomaticComplexity","countDecisionPoints","isRoot","decisionNodeTypes","isTryElseClause","findCyclomaticHotspots","depth","nextDepth","DEFAULT_CYCLOMATIC_THRESHOLDS","COMPLEXITY","stripQuotes","paramsNode","findParametersNode","typed","extracted","extractTypedParameter","filter","a","primitiveTypeNames","PRIMITIVE_OBSESSION","findParameterCollisions","valuesByVariable","Map","firstOccurrence","isVariableRef","variableReferenceNodeTypes","record","varNode","v","left","right","getEqualityComparisons","stringLiteral","getMembershipComparisons","sample","LOW","findStringlyTypedControlFlow","printUsage","filePath","cyclomatic","cognitive","flag","undefined","parseArgs","exit","adapter","resolveLanguageForFile","sourceCode","parser","grammarPath","grammar","analyzeSource","DEFAULT_NESTING_THRESHOLDS","hasBlockingViolation","main","catch","nestingControlTypes","NESTING","TYPESCRIPT","block","ifStatement","forStatement","whileStatement","importStatement","importFromStatement","expressionStatement","assignment","exportStatement","comment","integerLiteral","floatLiteral","parameterChildTypes","opToken","nameNode","typeAnnotation","typeNode","getElseIfBranches","sourceText","lineStartOffsets","low","high","mid","NAMING","COHERENCE","MAGIC","PARAMETERS","INVERSION","MATCH_OPPORTUNITY","LOGICAL_CONTROL_FLOW","parametersType","found","params","paramCount","DEFAULT_COHERENCE_THRESHOLDS","largeFunctionLines","maxLargeFunctions","fileName","functions","largeFunctions","fn","lineCount","baseName","DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS","minBranches","consumed","topIfNode","branches","ifNode","flatSiblings","current","nestedIf","collectChainBranches","branch","perBranchDiscriminants","branchNode","otherBranches","isLiteral","literalValue","variable","collectBranchDiscriminants","discriminants","commonVariable","d","analyzeChain","require","statements","trim","firstStatement","ifBody","totalLines","nestingLevel","validationChecks","firstCheck","analyzeNestedValidation","maxNesting","nestedIfLocation","countNesting","analyzeNestedIfs","analyzeFunction","LANGUAGES","python","PYTHON","fsharp","FSHARP","typescript","EXTENSION_TO_LANGUAGE_ID","dotIndex","extension","toLowerCase","languageId","DEFAULT_MAGIC_VALUES_OPTIONS","enabled","parseInt","parseFloat","grandparent","isInConstantContext","isDocstring","content","createPositionLookup","analyzeNesting","analyzeFunctionComplexity","analyzeCognitiveComplexity","analyzeFileCoherence","coherence","analyzeMagicValues","magicValues","analyzeParameterCount","analyzeInversionOpportunities","analyzePrimitiveObsession","analyzeMatchOpportunities","matchOpportunity","analyzeLogicalControlFlow","patternNode","rawRight","allStrings","__webpack_module_cache__","leafPrototypes","getProto","__webpack_require__","moduleId","cachedModule","__webpack_modules__","t","mode","ns","r","def","definition","o","toStringTag","__webpack_exports__"],"sourceRoot":""}