energy-state-analyzer 0.2.0 → 0.4.0

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","mappings":"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","sources":["webpack://energy-state-analyzer/./src/cli.ts","webpack://energy-state-analyzer/./src/core/analyze.ts","webpack://energy-state-analyzer/./src/core/detectors/cognitive.ts","webpack://energy-state-analyzer/./src/core/detectors/coherence.ts","webpack://energy-state-analyzer/./src/core/detectors/cyclomatic.ts","webpack://energy-state-analyzer/./src/core/detectors/inversion.ts","webpack://energy-state-analyzer/./src/core/detectors/logicalControlFlow.ts","webpack://energy-state-analyzer/./src/core/detectors/magicNumber.ts","webpack://energy-state-analyzer/./src/core/detectors/magicString.ts","webpack://energy-state-analyzer/./src/core/detectors/matchOpportunity.ts","webpack://energy-state-analyzer/./src/core/detectors/nesting.ts","webpack://energy-state-analyzer/./src/core/detectors/opaqueBoolean.ts","webpack://energy-state-analyzer/./src/core/detectors/parameterCount.ts","webpack://energy-state-analyzer/./src/core/detectors/primitiveObsession.ts","webpack://energy-state-analyzer/./src/core/position.ts","webpack://energy-state-analyzer/./src/languages/fsharp.ts","webpack://energy-state-analyzer/./src/languages/index.ts","webpack://energy-state-analyzer/./src/languages/python.ts","webpack://energy-state-analyzer/./src/languages/typescript.ts","webpack://energy-state-analyzer/./src/types.ts","webpack://energy-state-analyzer/external node-commonjs \"fs\"","webpack://energy-state-analyzer/external node-commonjs \"fs/promises\"","webpack://energy-state-analyzer/external node-commonjs \"path\"","webpack://energy-state-analyzer/./node_modules/web-tree-sitter/web-tree-sitter.cjs","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":["#!/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, AnalyzeThresholds } from './core/analyze';\nimport { LanguageAdapter } from './core/language';\nimport { DEFAULT_NESTING_THRESHOLDS } from './core/detectors/nesting';\nimport { DEFAULT_CYCLOMATIC_THRESHOLDS } from './core/detectors/cyclomatic';\nimport { DEFAULT_COGNITIVE_THRESHOLDS } from './core/detectors/cognitive';\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\ntype ThresholdOverride = { mediumThreshold?: number; highThreshold?: number };\n\n// decision: returns undefined (not the detector's own default) when neither flag was passed —\n// analyzeSource already falls back to each detector's own DEFAULT_*_THRESHOLDS when its entry is\n// undefined, so resolving the default here too would just be a second place that default could\n// drift out of sync with the detector module that owns it\nfunction resolveThresholdOverride<T extends ThresholdOverride>(override: ThresholdOverride, defaults: T): T | undefined {\n    if (override.mediumThreshold === undefined && override.highThreshold === undefined) {\n        return undefined;\n    }\n    return {\n        ...defaults,\n        mediumThreshold: override.mediumThreshold ?? defaults.mediumThreshold,\n        highThreshold: override.highThreshold ?? defaults.highThreshold\n    };\n}\n\nfunction buildThresholds(parsed: ReturnType<typeof parseArgs>): AnalyzeThresholds {\n    return {\n        nesting: resolveThresholdOverride(parsed.nesting, DEFAULT_NESTING_THRESHOLDS),\n        cyclomatic: resolveThresholdOverride(parsed.cyclomatic, DEFAULT_CYCLOMATIC_THRESHOLDS),\n        cognitive: resolveThresholdOverride(parsed.cognitive, DEFAULT_COGNITIVE_THRESHOLDS)\n    };\n}\n\nasync function loadParser(adapter: LanguageAdapter) {\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    return parser;\n}\n\nasync function main(): Promise<void> {\n    const parsed = parseArgs(process.argv.slice(2));\n    const { filePath } = parsed;\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    const parser = await loadParser(adapter);\n    const tree = parser.parse(sourceCode);\n\n    const violations: EnergyViolation[] = analyzeSource(sourceCode, tree, adapter, filePath, buildThresholds(parsed));\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 } 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 { analyzeMagicNumbers, MagicNumberOptions, DEFAULT_MAGIC_NUMBER_OPTIONS } from './detectors/magicNumber';\nimport { analyzeMagicStrings, MagicStringOptions, DEFAULT_MAGIC_STRING_OPTIONS } from './detectors/magicString';\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';\nimport { analyzeOpaqueBooleanLiteral } from './detectors/opaqueBoolean';\n\nexport interface AnalyzeThresholds {\n    nesting?: NestingThresholds;\n    cyclomatic?: CyclomaticThresholds;\n    cognitive?: CognitiveThresholds;\n    coherence?: CoherenceThresholds;\n    matchOpportunity?: MatchOpportunityThresholds;\n    magicNumber?: MagicNumberOptions;\n    magicString?: MagicStringOptions;\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 magicNumber/magicString) — 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(...analyzeMagicNumbers(tree, positions, language, thresholds.magicNumber ?? DEFAULT_MAGIC_NUMBER_OPTIONS));\n    violations.push(...analyzeMagicStrings(tree, positions, language, thresholds.magicString ?? DEFAULT_MAGIC_STRING_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    violations.push(...analyzeOpaqueBooleanLiteral(tree, positions, language));\n\n    return violations;\n}\n","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","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    // Share (0-1) of a file's functions that must share a leading name word (e.g. all\n    // `extractX`/`extractY`) for the file to be treated as one coherent domain broken into many\n    // small steps, rather than a grab-bag of unrelated helpers, and skip the raw function-count\n    // sprawl check below.\n    singleDomainNameShare: number;\n}\n\nexport const DEFAULT_COHERENCE_THRESHOLDS: CoherenceThresholds = {\n    largeFunctionLines: 20,\n    maxLargeFunctions: 5,\n    singleDomainNameShare: 0.7\n};\n\nfunction lineCount(node: any): number {\n    return node.endPosition.row - node.startPosition.row + 1;\n}\n\n// decision: a raw function name is a weak signal on its own, but a *dominant leading word*\n// shared across most of a file's functions (extractFoo/extractBar/extractBaz) is a cheap,\n// AST-only proxy for \"this file is one coherent domain factored into many small steps\" —\n// exactly the case the function-count sprawl check below would otherwise misflag, since it\n// can't tell that apart from an actual grab-bag of unrelated helpers by count alone\nfunction leadingNameWord(node: any): string | null {\n    const nameNode = node.children?.find((c: any) => c.type === 'identifier');\n    if (!nameNode?.text) {\n        return null;\n    }\n    const match = /^[a-z]+/.exec(nameNode.text);\n    return match ? match[0] : nameNode.text.toLowerCase();\n}\n\nfunction looksLikeSingleDomain(functions: any[], minShare: number): boolean {\n    const leadingWords = functions.map(leadingNameWord).filter((word): word is string => word !== null);\n    if (leadingWords.length === 0) {\n        return false;\n    }\n\n    const wordCounts = new Map<string, number>();\n    for (const word of leadingWords) {\n        wordCounts.set(word, (wordCounts.get(word) ?? 0) + 1);\n    }\n\n    const dominantWordCount = Math.max(...wordCounts.values());\n    return dominantWordCount / leadingWords.length >= minShare;\n}\n\nfunction collectFunctionsAndImports(tree: any, language: LanguageAdapter): { functions: any[]; imports: string[] } {\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    return { functions, imports };\n}\n\n// decision: the raw function-count trigger (8/12) and its severity escalation (15) are\n// deliberately not part of CoherenceThresholds like largeFunctionLines/maxLargeFunctions are —\n// they're secondary heuristics tuned around the utils-file naming proxy, not a threshold users\n// are expected to retune independently\nconst UTILS_FILE_FUNCTION_THRESHOLD = 8;\nconst GENERIC_FUNCTION_COUNT_THRESHOLD = 12;\nconst HIGH_FUNCTION_COUNT_THRESHOLD = 15;\nconst LARGE_FUNCTION_SEVERITY_MULTIPLIER = 1.5;\nconst IMPORT_COUNT_THRESHOLD = 10;\nconst HIGH_IMPORT_COUNT_THRESHOLD = 15;\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\"\nfunction checkFunctionCountSprawl(functions: any[], fileName: string, thresholds: CoherenceThresholds): EnergyViolation | null {\n    if (functions.length <= UTILS_FILE_FUNCTION_THRESHOLD) {\n        return null;\n    }\n\n    const baseName = fileName.split('/').pop() || '';\n    const isUtilsFile = baseName.includes('util') || baseName.includes('helper') || baseName.includes('common');\n    // decision: an explicit utils/helper/common filename overrides the naming-cohesion signal — a module that already admits to being a grab-bag in its own name doesn't get to argue its way out via consistent prefixes\n    const singleDomain = !isUtilsFile && looksLikeSingleDomain(functions, thresholds.singleDomainNameShare);\n\n    if (!isUtilsFile && (functions.length <= GENERIC_FUNCTION_COUNT_THRESHOLD || singleDomain)) {\n        return null;\n    }\n\n    return {\n        line: 0,\n        column: 0,\n        type: VIOLATION_TYPE.COHERENCE,\n        severity: functions.length > HIGH_FUNCTION_COUNT_THRESHOLD ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n        message: `File coherence warning: ${functions.length} functions in one file. Consider splitting by domain.`\n    };\n}\n\n// Flag files with too many large functions, regardless of total function count - a module with\n// 30 small functions is fine, one with 6 sprawling ones isn't.\nfunction checkLargeFunctionSprawl(functions: any[], thresholds: CoherenceThresholds): EnergyViolation | null {\n    const largeFunctions = functions.filter(fn => lineCount(fn) > thresholds.largeFunctionLines);\n    if (largeFunctions.length <= thresholds.maxLargeFunctions) {\n        return null;\n    }\n\n    return {\n        line: 0,\n        column: 0,\n        type: VIOLATION_TYPE.COHERENCE,\n        severity: largeFunctions.length > thresholds.maxLargeFunctions * LARGE_FUNCTION_SEVERITY_MULTIPLIER ? 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)\nfunction checkImportSprawl(imports: string[]): EnergyViolation | null {\n    if (imports.length <= IMPORT_COUNT_THRESHOLD) {\n        return null;\n    }\n\n    return {\n        line: 0,\n        column: 0,\n        type: VIOLATION_TYPE.COHERENCE,\n        severity: imports.length > HIGH_IMPORT_COUNT_THRESHOLD ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n        message: `Import sprawl: ${imports.length} imports suggest this file does too much.`\n    };\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 { functions, imports } = collectFunctionsAndImports(tree, language);\n\n    return [\n        checkFunctionCountSprawl(functions, fileName, thresholds),\n        checkLargeFunctionSprawl(functions, thresholds),\n        checkImportSprawl(imports)\n    ].filter((violation): violation is EnergyViolation => violation !== null);\n}\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';\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            // decision: matches against language.nestingControlTypes rather than the\n            // nodeTypes.ifStatement/forStatement/whileStatement trio directly — TypeScript's\n            // `for...of`/`for...in` parses as its own for_in_statement node, distinct from\n            // nodeTypes.forStatement's plain `for_statement`, and nestingControlTypes is the\n            // per-language set that already accounts for that (bug found by running this\n            // detector on its own source: a sibling for-of loop went unseen by the old filter,\n            // making its lone if-sibling look like the only statement in this body and get\n            // mistaken for a validation-chain step)\n            const statements = currentNode.children?.filter((child: any) =>\n                language.nestingControlTypes.includes(child.type)\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            // invariant: never descends into a nested function/method's body — that function is\n            // walked as its own separate analyzeFunction call once traverse() reaches it, so\n            // counting its if-nesting here too would both double-report the same location and\n            // misattribute nesting depth to the wrong enclosing function (mirrors the same rule\n            // in cognitive.ts's walk())\n            if (language.isFunctionDefinition(node)) {\n                return;\n            }\n\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 { 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 { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\nexport interface MagicNumberOptions {\n    enabled: boolean;\n    // Numeric literals that never carry hidden meaning worth naming (loop\n    // bounds, unit steps) — checked against the literal's signed value.\n    allowlist: number[];\n}\n\nexport const DEFAULT_MAGIC_NUMBER_OPTIONS: MagicNumberOptions = {\n    enabled: true,\n    allowlist: [0, 1, -1, 2]\n};\n\n// The \"Magic Number\" detector: numbers don't get an interpolation-style escape hatch the way\n// strings do, so this stays broad (any significant literal outside a named binding) and leans\n// on the allowlist plus a few structural exemptions (index position, default parameter value)\n// to keep it from flagging the common idioms where a bare number isn't actually magic.\nexport function analyzeMagicNumbers(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter,\n    options: MagicNumberOptions = DEFAULT_MAGIC_NUMBER_OPTIONS\n): EnergyViolation[] {\n    const violations: EnergyViolation[] = [];\n    if (!options.enabled) {\n        return violations;\n    }\n    const { nodeTypes } = language;\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                // decision: Python wraps every top-level `name = value` in an\n                // `expression_statement` between the assignment and the module root (unlike\n                // TS's `lexical_declaration`, which sits directly under `program`) — unwrap it\n                // before checking against module/export so `MAX_RETRIES = 5` at module scope\n                // is still recognized as a constant binding.\n                let grandparent = parent.parent;\n                if (grandparent?.type === nodeTypes.expressionStatement) {\n                    grandparent = grandparent.parent;\n                }\n                if (grandparent?.type === nodeTypes.module) {\n                    // decision: F#'s `declaration_expression` node type is reused both for the\n                    // true module root and for wrapping a nested `let` binding's continuation\n                    // inside a function body (there's no separate node type for \"this let is\n                    // the function's actual last expression\" vs \"this let is module-level\") — so\n                    // matching nodeTypes.module here isn't enough on its own; this also has to\n                    // rule out an enclosing function definition somewhere further up\n                    return !hasEnclosingFunction(parent);\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 hasEnclosingFunction(assignmentNode: any): boolean {\n        let ancestor = assignmentNode.parent;\n        while (ancestor) {\n            if (language.isFunctionDefinition(ancestor)) {\n                return true;\n            }\n            ancestor = ancestor.parent;\n        }\n        return false;\n    }\n\n    function isIndexPosition(node: any): boolean {\n        return !!node.parent && language.subscriptNodeTypes.includes(node.parent.type);\n    }\n\n    // decision: a plain `-` unary parent isn't its own node type across every grammar, so this\n    // checks the structural shape (a 2-child parent whose first child is a literal `-` token)\n    // instead of adding another per-language adapter hook for something this mechanical\n    function signedValue(node: any, rawValue: number): number {\n        const parent = node.parent;\n        const isNegated = parent?.children?.length === 2 && parent.children[0]?.text === '-';\n        return isNegated ? -rawValue : rawValue;\n    }\n\n    function traverse(node: any) {\n        if (node.type === nodeTypes.integerLiteral || node.type === nodeTypes.floatLiteral) {\n            // decision: always parseFloat, even for integerLiteral nodes — TS has no separate\n            // floatLiteral node type (both map to nodeTypes.integerLiteral), so parseInt would\n            // silently truncate a literal like `1.08` down to `1` and match the allowlist\n            const rawValue = parseFloat(node.text);\n            // decision: skips non-numeric text outright rather than falling through to the\n            // allowlist/exemption checks — F#'s float grammar nests a `float`-typed fragment\n            // node (digits/'.'/digits) inside its own `float`-typed literal, and TS's\n            // `predefined_type` keyword token for the `number` annotation shares nodeTypes'\n            // 'number' node type with the actual numeric-literal node; neither is a real value\n            if (!Number.isNaN(rawValue)) {\n                const value = signedValue(node, rawValue);\n\n                const isExempt = options.allowlist.includes(value)\n                    || isInConstantContext(node)\n                    || isIndexPosition(node)\n                    || language.isDefaultParameterValue(node);\n\n                if (!isExempt) {\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            // A literal's own children (if any) are fragments of the same value, not\n            // separate literals — never descend into them.\n            return;\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\nexport interface MagicStringOptions {\n    enabled: boolean;\n    // Only flag a string once it recurs at a decision point at least this many times across\n    // the file — mirrors Sonar's S1192, and cuts single-use false positives further.\n    minDuplicates: number;\n    // Literal contents that are never worth naming regardless of how often they recur.\n    allowlist: string[];\n}\n\nexport const DEFAULT_MAGIC_STRING_OPTIONS: MagicStringOptions = {\n    enabled: true,\n    minDuplicates: 2,\n    allowlist: ['', 'utf-8', '__main__']\n};\n\n// The \"Magic String\" detector: unlike numbers, strings get a narrow scope — only literals\n// standing at a decision point (compared, checked for membership, or used as a dict/object\n// key) are candidates, since that's where an unnamed string actually risks a silent typo. Any\n// other string (a message, a docstring, an interpolated template) is left alone entirely.\nexport function analyzeMagicStrings(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter,\n    options: MagicStringOptions = DEFAULT_MAGIC_STRING_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        return node.parent?.type === nodeTypes.expressionStatement;\n    }\n\n    function stripQuotes(text: string): string {\n        return text.length >= 2 ? text.slice(1, -1) : text;\n    }\n\n    function isEqualityComparisonOperand(node: any): boolean {\n        // decision: also checks the grandparent, not just the parent — F#'s grammar wraps a\n        // literal operand in an intermediate `const` node before it reaches the\n        // `infix_expression`, so the comparison node itself sits one level further up than in\n        // Python/TS. Checking the parent alone would silently drop every F# string comparison.\n        const candidates = [node.parent, node.parent?.parent].filter(Boolean);\n        // decision: compares node identity by `.id`, not `===` — web-tree-sitter mints a fresh\n        // JS wrapper object on every `.children`/`.parent` access, so two accessors that reach\n        // the same underlying tree node are not reference-equal even though `.id` matches\n        return candidates.some(candidate =>\n            language.getEqualityComparisons(candidate).some(({ left, right }) => left.id === node.id || right.id === node.id));\n    }\n\n    function isMembershipOperand(node: any, content: string): boolean {\n        const container = node.parent?.parent;\n        if (!container) {\n            return false;\n        }\n        return language.getMembershipComparisons(container).some(({ values }) => values.includes(content));\n    }\n\n    function isKeyOrIndexPosition(node: any): boolean {\n        return !!node.parent && language.subscriptNodeTypes.includes(node.parent.type);\n    }\n\n    function isDecisionPoint(node: any, content: string): boolean {\n        return isEqualityComparisonOperand(node) || isMembershipOperand(node, content) || isKeyOrIndexPosition(node);\n    }\n\n    function isExempt(node: any, content: string): boolean {\n        return isDocstring(node)\n            || language.isFormattedOrInterpolatedString(node)\n            || options.allowlist.includes(content)\n            || content.length <= 1;\n    }\n\n    interface Candidate { node: any; content: string; }\n    const candidates: Candidate[] = [];\n\n    function traverse(node: any) {\n        if (node.type === nodeTypes.stringLiteral) {\n            const content = stripQuotes(node.text);\n            if (isDecisionPoint(node, content) && !isExempt(node, content)) {\n                candidates.push({ node, content });\n            }\n        }\n\n        for (const child of node.children) {\n            traverse(child);\n        }\n    }\n\n    traverse(tree.rootNode);\n\n    const byContent = new Map<string, Candidate[]>();\n    for (const candidate of candidates) {\n        const group = byContent.get(candidate.content) ?? [];\n        group.push(candidate);\n        byContent.set(candidate.content, group);\n    }\n\n    for (const [content, group] of byContent) {\n        if (group.length < options.minDuplicates) {\n            continue;\n        }\n        const first = group[0].node;\n        const position = positions.toPosition(first.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: \"${content}\" is compared/keyed against directly ${group.length} time(s). Consider extracting to a named constant or enum.`\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","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 { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\n// The \"Opaque Boolean Literal\" detector: a bare `true`/`false` passed positionally\n// into a call gives the reader no information about what it means without tracing\n// into the callee's signature — unlike primitive-obsession's swap-risk check, this\n// doesn't need a second adjacent parameter to be a problem; one opaque literal is\n// enough. Naming it at the call site (whatever the language allows: a keyword\n// argument, an object-literal field, F#'s named-argument syntax) fixes the\n// readability problem even where it isn't enforced by the type checker — see\n// isPositionalCallArgument's per-language doc for how each grammar distinguishes\n// labeled from positional.\nfunction buildViolation(node: any, positions: PositionLookup): EnergyViolation {\n    const position = positions.toPosition(node.startIndex);\n    return {\n        line: position.line,\n        column: position.column,\n        type: VIOLATION_TYPE.OPAQUE_BOOLEAN,\n        severity: SEVERITY.LOW,\n        message: `Opaque boolean literal: a bare '${node.text}' passed positionally tells the reader nothing without checking the callee's signature. Name it at the call site (a keyword argument, an object-literal field, or F#'s named-argument syntax) — or better, split into two clearly named functions (e.g. enableX()/disableX()) or use an enum.`\n    };\n}\n\nexport function analyzeOpaqueBooleanLiteral(tree: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n    const violations: EnergyViolation[] = [];\n\n    function traverse(node: any) {\n        if (language.isBooleanLiteral(node) && language.isPositionalCallArgument(node)) {\n            violations.push(buildViolation(node, positions));\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// 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';\nimport { findParametersNode } from './parameterCount';\n\ninterface TypedParam {\n    name: string;\n    type: string;\n    node: any;\n    keywordOnly: boolean;\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.\n//\n// decision: a pair is suppressed only when BOTH params sit past a\n// keywordOnlyBoundaryTypes marker (Python's bare `*` / `*args`) — the signature\n// itself must make positional calls impossible, not just \"some call sites happen\n// to use keywords\". A signature that still allows positional calls will\n// eventually get one.\n// known gap: Python's `**kwargs` dict-splatting can reintroduce positional-style\n// swap risk even past a keyword-only boundary (a caller building the dict by\n// hand can still transpose the values) — not worth detecting, left undocumented\n// in code but called out here for future readers.\nfunction findParameterCollisions(paramsNode: any, positions: PositionLookup, language: LanguageAdapter): EnergyViolation[] {\n    const violations: EnergyViolation[] = [];\n    let keywordOnly = false;\n    const typed: TypedParam[] = [];\n    for (const n of paramsNode.children) {\n        if (language.keywordOnlyBoundaryTypes.includes(n.type)) {\n            keywordOnly = true;\n            continue;\n        }\n        const extracted = language.extractTypedParameter(n);\n        if (extracted) {\n            typed.push({ ...extracted, node: n, keywordOnly });\n        }\n    }\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            continue;\n        }\n        if (a.keywordOnly && b.keywordOnly) {\n            continue;\n        }\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 ${language.distinctTypeAdvice} so the type checker catches it.`\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","// 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","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    // F#'s named-argument syntax is optional at the call site, so it doesn't prevent a\n    // future positional call — not a valid swap-risk mitigation. See language.ts's field doc.\n    keywordOnlyBoundaryTypes: [],\n    distinctTypeAdvice: 'a single-case union type',\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    // F# indexes via `.[i]` rather than a dedicated subscript node — left unmodeled rather\n    // than guessed at with a fragile node-type match.\n    subscriptNodeTypes: [],\n    // F# also has interpolated ($\"...\") strings, but they aren't distinguished from plain\n    // strings here — a known gap, same tradeoff as leaving callNodeTypes unmodeled above.\n    isFormattedOrInterpolatedString(): boolean {\n        return false;\n    },\n    isDefaultParameterValue(): boolean {\n        return false;\n    },\n    // A bool literal parses as a `const` node wrapping a `bool` child (its .text is\n    // already \"true\"/\"false\", same as Python/TS's dedicated literal node types).\n    isBooleanLiteral(node: any): boolean {\n        return node?.type === 'const' && node.children?.length === 1 && node.children[0]?.type === 'bool';\n    },\n    // F# has no dedicated call-expression or argument-list node — curried application\n    // (`f true`) and paren-tuple application (`f(true, x)`) both parse as\n    // application_expression, and named-argument syntax (`retries = true`) reuses the\n    // same infix_expression node the primitive-obsession detector treats as equality\n    // elsewhere in this grammar. Three shapes count as \"positional\":\n    //   1. curried: `application_expression(callee, true)` — the literal is the\n    //      argument (not callee) child of an application_expression directly.\n    //   2. paren, single arg: `f(true)` — same shape as (1), the parens contribute no\n    //      extra node.\n    //   3. paren, multiple args: `f(true, x)` — the literal is a direct element of a\n    //      `tuple_expression` that is itself an application_expression's argument.\n    // A named argument's literal sits one level deeper, inside `infix_expression`\n    // (case 1/2's `application_expression` child, or case 3's `tuple_expression`\n    // element) — never a direct child of either, so it never matches below without a\n    // separate \"is labeled\" check.\n    isPositionalCallArgument(node: any): boolean {\n        const parent = node?.parent;\n        if (parent?.type === 'application_expression') {\n            // Guard against the literal being the callee itself — never true in\n            // practice (a bool can't be applied to arguments), kept for safety.\n            return parent.children?.[0]?.id !== node.id;\n        }\n        return parent?.type === 'tuple_expression' && parent.parent?.type === 'application_expression';\n    }\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","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    keywordOnlyBoundaryTypes: ['keyword_separator', 'list_splat_pattern'],\n    distinctTypeAdvice: 'NewType or a dataclass',\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    subscriptNodeTypes: ['subscript'],\n    isFormattedOrInterpolatedString(node: any): boolean {\n        if (node?.children?.some((c: any) => c.type === 'interpolation')) {\n            // f-string\n            return true;\n        }\n        // decision: compares node identity by `.id`, not `===` — web-tree-sitter mints a fresh\n        // JS wrapper object on every `.children`/`.parent` access, so two accessors that reach\n        // the same underlying tree node are not reference-equal even though `.id` matches\n        const parent = node?.parent;\n        if (parent?.type === 'binary_operator' && parent.children?.[0]?.id === node.id\n            && parent.children?.some((c: any) => c.type === '%')) {\n            // \"%s\" % value\n            return true;\n        }\n        if (parent?.type === 'attribute' && parent.children?.[0]?.id === node.id) {\n            const methodName = parent.children?.find((c: any) => c.type === 'identifier');\n            if (methodName?.text === 'format' && parent.parent?.type === 'call') {\n                return true;\n            }\n        }\n        return false;\n    },\n    isDefaultParameterValue(node: any): boolean {\n        const parent = node?.parent;\n        return (parent?.type === 'default_parameter' || parent?.type === 'typed_default_parameter')\n            && parent.children?.[parent.children.length - 1]?.id === node.id;\n    },\n    isBooleanLiteral(node: any): boolean {\n        return node?.type === 'true' || node?.type === 'false';\n    },\n    // A keyword argument (`retries=True`) wraps the literal in its own `keyword_argument`\n    // node, so a labeled boolean's parent is never `argument_list` directly.\n    isPositionalCallArgument(node: any): boolean {\n        return node?.parent?.type === 'argument_list' && node.parent.parent?.type === 'call';\n    }\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    // TS has no enforced-keyword-only parameter syntax — see language.ts's field doc.\n    keywordOnlyBoundaryTypes: [],\n    distinctTypeAdvice: 'a branded/nominal type (e.g. a tagged type alias)',\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    subscriptNodeTypes: ['subscript_expression'],\n    // TS has no node type where an interpolated/formatted string still shares\n    // stringLiteral's node type — template literals parse as `template_string`,\n    // which the traversal never visits as a string literal in the first place.\n    isFormattedOrInterpolatedString(): boolean {\n        return false;\n    },\n    isDefaultParameterValue(node: any): boolean {\n        // decision: compares node identity by `.id`, not `===` — see the matching comment in\n        // python.ts's isFormattedOrInterpolatedString for why\n        // decision: a parameter with a default value (`x: number = 1`) still parses as\n        // `required_parameter`, not `optional_parameter` (that node type is reserved for `x?:\n        // number`) — so this checks for the `=` child rather than trusting the parameter's own\n        // node type to signal \"has a default\"\n        const parent = node?.parent;\n        if (parent?.type !== 'required_parameter' && parent?.type !== 'optional_parameter') {\n            return false;\n        }\n        return parent.children?.some((c: any) => c.type === '=')\n            && parent.children?.[parent.children.length - 1]?.id === node.id;\n    },\n    isBooleanLiteral(node: any): boolean {\n        return node?.type === 'true' || node?.type === 'false';\n    },\n    // An object-literal field (`{ retries: true }`) wraps the literal in `pair` inside\n    // `object`, so a labeled boolean's parent is never `arguments` directly.\n    isPositionalCallArgument(node: any): boolean {\n        return node?.parent?.type === 'arguments' && node.parent.parent?.type === 'call_expression';\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    OPAQUE_BOOLEAN: 'opaque-boolean' 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' | 'opaque-boolean';\n    severity: 'low' | 'medium' | 'high';\n    message: string;\n    hotspots?: ComplexityHotspot[];\n}\n","module.exports = require(\"fs\");","module.exports = require(\"fs/promises\");","module.exports = require(\"path\");","\"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/web-tree-sitter.cjs\nvar require_web_tree_sitter = __commonJS({\n  \"lib/web-tree-sitter.cjs\"(exports, module) {\n    \"use strict\";\n    var Module = (() => {\n      var _scriptName = typeof document != \"undefined\" ? document.currentScript?.src : void 0;\n      return async function(moduleArg = {}) {\n        var moduleRtn;\n        var Module = moduleArg;\n        var ENVIRONMENT_IS_WEB = typeof window == \"object\";\n        var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != \"undefined\";\n        var ENVIRONMENT_IS_NODE = typeof process == \"object\" && process.versions?.node && process.type != \"renderer\";\n        Module.currentQueryProgressCallback = null;\n        Module.currentProgressCallback = null;\n        Module.currentLogCallback = null;\n        Module.currentParseCallback = null;\n        var arguments_ = [];\n        var thisProgram = \"./this.program\";\n        var quit_ = /* @__PURE__ */ __name((status, toThrow) => {\n          throw toThrow;\n        }, \"quit_\");\n        if (typeof __filename != \"undefined\") {\n          _scriptName = __filename;\n        } else if (ENVIRONMENT_IS_WORKER) {\n          _scriptName = self.location.href;\n        }\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          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 (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          try {\n            scriptDirectory = new URL(\".\", _scriptName).href;\n          } catch {\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 = console.log.bind(console);\n        var err = console.error.bind(console);\n        var dynamicLibraries = [];\n        var wasmBinary;\n        var ABORT = false;\n        var EXITSTATUS;\n        var isFileURI = /* @__PURE__ */ __name((filename) => filename.startsWith(\"file://\"), \"isFileURI\");\n        var readyPromiseResolve, readyPromiseReject;\n        var wasmMemory;\n        var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;\n        var HEAP64, HEAPU64;\n        var HEAP_DATA_VIEW;\n        var runtimeInitialized = false;\n        function updateMemoryViews() {\n          var b = wasmMemory.buffer;\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          Module[\"HEAP_DATA_VIEW\"] = HEAP_DATA_VIEW = new DataView(b);\n          LE_HEAP_UPDATE();\n        }\n        __name(updateMemoryViews, \"updateMemoryViews\");\n        function initMemory() {\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        }\n        __name(initMemory, \"initMemory\");\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        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(\"web-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 && !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            assignWasmExports(wasmExports);\n            return wasmExports;\n          }\n          __name(receiveInstance, \"receiveInstance\");\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                resolve(receiveInstance(mod, inst));\n              });\n            });\n          }\n          wasmBinaryFile ??= findWasmBinary();\n          var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info2);\n          var exports2 = receiveInstantiationResult(result);\n          return exports2;\n        }\n        __name(createWasm, \"createWasm\");\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_ATOMICS_NATIVE_BYTE_ORDER = [];\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_I64 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getBigInt64(byteOffset, true), \"LE_HEAP_LOAD_I64\");\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_I64 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setBigInt64(byteOffset, value, true), \"LE_HEAP_STORE_I64\");\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.push(cb), \"addOnPostRun\");\n        var onPreRuns = [];\n        var addOnPreRun = /* @__PURE__ */ __name((cb) => onPreRuns.push(cb), \"addOnPreRun\");\n        var UTF8Decoder = typeof TextDecoder != \"undefined\" ? new TextDecoder() : void 0;\n        var findStringEnd = /* @__PURE__ */ __name((heapOrArray, idx, maxBytesToRead, ignoreNul) => {\n          var maxIdx = idx + maxBytesToRead;\n          if (ignoreNul) return maxIdx;\n          while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;\n          return idx;\n        }, \"findStringEnd\");\n        var UTF8ArrayToString = /* @__PURE__ */ __name((heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {\n          var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);\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 getStringList() {\n            var count2 = getLEB();\n            var rtn = [];\n            while (count2--) rtn.push(getString());\n            return rtn;\n          }\n          __name(getStringList, \"getStringList\");\n          function failIf(condition, message) {\n            if (condition) throw new Error(message);\n          }\n          __name(failIf, \"failIf\");\n          if (binary2 instanceof WebAssembly.Module) {\n            var dylinkSection = WebAssembly.Module.customSections(binary2, \"dylink.0\");\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            var name2 = getString();\n            failIf(name2 !== \"dylink.0\");\n          }\n          var customSection = {\n            neededDynlibs: [],\n            tlsExports: /* @__PURE__ */ new Set(),\n            weakImports: /* @__PURE__ */ new Set(),\n            runtimePaths: []\n          };\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_DYLINK_RUNTIME_PATH = 5;\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              customSection.neededDynlibs = getStringList();\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 if (subsectionType === WASM_DYLINK_RUNTIME_PATH) {\n              customSection.runtimePaths = getStringList();\n            } else {\n              offset += subsectionSize;\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 LE_HEAP_LOAD_I64((ptr >> 3) * 8);\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 = 78240;\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 uleb128EncodeWithLen = /* @__PURE__ */ __name((arr) => {\n          const n = arr.length;\n          return [n % 128 | 128, n >> 7, ...arr];\n        }, \"uleb128EncodeWithLen\");\n        var wasmTypeCodes = {\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        var generateTypePack = /* @__PURE__ */ __name((types) => uleb128EncodeWithLen(Array.from(types, (type) => {\n          var code = wasmTypeCodes[type];\n          return code;\n        })), \"generateTypePack\");\n        var convertJsFunctionToWasm = /* @__PURE__ */ __name((func2, sig) => {\n          var bytes = Uint8Array.of(\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            ...uleb128EncodeWithLen([\n              1,\n              // count: 1\n              96,\n              // param types\n              ...generateTypePack(sig.slice(1)),\n              // return types (for now only supporting [] if `void` and single [T] otherwise)\n              ...generateTypePack(sig[0] === \"v\" ? \"\" : sig[0])\n            ]),\n            // The rest of the module is static\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(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            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          return wasmTable[\"grow\"](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 = [], promising = false) => {\n          var func2 = getWasmTableEntry(ptr);\n          var rtn = func2(...args2);\n          function convert(rtn2) {\n            return rtn2;\n          }\n          __name(convert, \"convert\");\n          return convert(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.push(cb), \"addOnPostCtor\");\n        var UTF8ToString = /* @__PURE__ */ __name((ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : \"\", \"UTF8ToString\");\n        var loadWebAssemblyModule = /* @__PURE__ */ __name((binary, flags, libName, localScope, handle) => {\n          var metadata = getDylinkMetadata(binary);\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            currentModuleWeakSymbols = metadata.weakImports;\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              return (async () => {\n                var instance2;\n                if (binary instanceof WebAssembly.Module) {\n                  instance2 = new WebAssembly.Instance(binary, info);\n                } else {\n                  ({ module: binary, instance: instance2 } = await WebAssembly.instantiate(binary, info));\n                }\n                return postInstantiation(binary, instance2);\n              })();\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          flags = {\n            ...flags,\n            rpath: {\n              parentLibPath: libName,\n              paths: metadata.runtimePaths\n            }\n          };\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 runDependencies = 0;\n        var dependenciesFulfilled = null;\n        var removeRunDependency = /* @__PURE__ */ __name((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        }, \"removeRunDependency\");\n        var addRunDependency = /* @__PURE__ */ __name((id) => {\n          runDependencies++;\n          Module[\"monitorRunDependencies\"]?.(runDependencies);\n        }, \"addRunDependency\");\n        var loadDylibs = /* @__PURE__ */ __name(async () => {\n          if (!dynamicLibraries.length) {\n            reportUndefinedSymbols();\n            return;\n          }\n          addRunDependency(\"loadDylibs\");\n          for (var lib of dynamicLibraries) {\n            await loadDynamicLibrary(lib, {\n              loadAsync: true,\n              global: true,\n              nodelete: true,\n              allowUndefined: true\n            });\n          }\n          reportUndefinedSymbols();\n          removeRunDependency(\"loadDylibs\");\n        }, \"loadDylibs\");\n        var 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              LE_HEAP_STORE_I64((ptr >> 3) * 8, 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_high = 78240;\n        var ___stack_low = 12704;\n        var ___stack_pointer = new WebAssembly.Global({\n          \"value\": \"i32\",\n          \"mutable\": true\n        }, 78240);\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 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 oldHeapSize = wasmMemory.buffer.byteLength;\n          var pages = (size - oldHeapSize + 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        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 _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 _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.codePointAt(i2);\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              i2++;\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        LE_ATOMICS_NATIVE_BYTE_ORDER = new Int8Array(new Int16Array([1]).buffer)[0] === 1 ? [\n          /* little endian */\n          ((x) => x),\n          ((x) => x),\n          void 0,\n          ((x) => x)\n        ] : [\n          /* big endian */\n          ((x) => x),\n          ((x) => ((x & 65280) << 8 | (x & 255) << 24) >> 16),\n          void 0,\n          ((x) => x >> 24 & 255 | x >> 8 & 65280 | (x & 65280) << 8 | (x & 255) << 24)\n        ];\n        function LE_HEAP_UPDATE() {\n          HEAPU16.unsigned = ((x) => x & 65535);\n          HEAPU32.unsigned = ((x) => x >>> 0);\n        }\n        __name(LE_HEAP_UPDATE, \"LE_HEAP_UPDATE\");\n        {\n          initMemory();\n          if (Module[\"noExitRuntime\"]) noExitRuntime = Module[\"noExitRuntime\"];\n          if (Module[\"print\"]) out = Module[\"print\"];\n          if (Module[\"printErr\"]) err = Module[\"printErr\"];\n          if (Module[\"dynamicLibraries\"]) dynamicLibraries = Module[\"dynamicLibraries\"];\n          if (Module[\"wasmBinary\"]) wasmBinary = Module[\"wasmBinary\"];\n          if (Module[\"arguments\"]) arguments_ = Module[\"arguments\"];\n          if (Module[\"thisProgram\"]) thisProgram = Module[\"thisProgram\"];\n          if (Module[\"preInit\"]) {\n            if (typeof Module[\"preInit\"] == \"function\") Module[\"preInit\"] = [Module[\"preInit\"]];\n            while (Module[\"preInit\"].length > 0) {\n              Module[\"preInit\"].shift()();\n            }\n          }\n        }\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        Module[\"LE_HEAP_STORE_I64\"] = LE_HEAP_STORE_I64;\n        var ASM_CONSTS = {};\n        var _malloc, _calloc, _realloc, _free, _ts_range_edit, _memcmp, _ts_language_symbol_count, _ts_language_state_count, _ts_language_abi_version, _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_point_edit, _ts_parser_delete, _ts_parser_reset, _ts_parser_set_language, _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_metadata_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, _setThrew, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, ___wasm_apply_data_relocs;\n        function assignWasmExports(wasmExports2) {\n          Module[\"_malloc\"] = _malloc = wasmExports2[\"malloc\"];\n          Module[\"_calloc\"] = _calloc = wasmExports2[\"calloc\"];\n          Module[\"_realloc\"] = _realloc = wasmExports2[\"realloc\"];\n          Module[\"_free\"] = _free = wasmExports2[\"free\"];\n          Module[\"_ts_range_edit\"] = _ts_range_edit = wasmExports2[\"ts_range_edit\"];\n          Module[\"_memcmp\"] = _memcmp = wasmExports2[\"memcmp\"];\n          Module[\"_ts_language_symbol_count\"] = _ts_language_symbol_count = wasmExports2[\"ts_language_symbol_count\"];\n          Module[\"_ts_language_state_count\"] = _ts_language_state_count = wasmExports2[\"ts_language_state_count\"];\n          Module[\"_ts_language_abi_version\"] = _ts_language_abi_version = wasmExports2[\"ts_language_abi_version\"];\n          Module[\"_ts_language_name\"] = _ts_language_name = wasmExports2[\"ts_language_name\"];\n          Module[\"_ts_language_field_count\"] = _ts_language_field_count = wasmExports2[\"ts_language_field_count\"];\n          Module[\"_ts_language_next_state\"] = _ts_language_next_state = wasmExports2[\"ts_language_next_state\"];\n          Module[\"_ts_language_symbol_name\"] = _ts_language_symbol_name = wasmExports2[\"ts_language_symbol_name\"];\n          Module[\"_ts_language_symbol_for_name\"] = _ts_language_symbol_for_name = wasmExports2[\"ts_language_symbol_for_name\"];\n          Module[\"_strncmp\"] = _strncmp = wasmExports2[\"strncmp\"];\n          Module[\"_ts_language_symbol_type\"] = _ts_language_symbol_type = wasmExports2[\"ts_language_symbol_type\"];\n          Module[\"_ts_language_field_name_for_id\"] = _ts_language_field_name_for_id = wasmExports2[\"ts_language_field_name_for_id\"];\n          Module[\"_ts_lookahead_iterator_new\"] = _ts_lookahead_iterator_new = wasmExports2[\"ts_lookahead_iterator_new\"];\n          Module[\"_ts_lookahead_iterator_delete\"] = _ts_lookahead_iterator_delete = wasmExports2[\"ts_lookahead_iterator_delete\"];\n          Module[\"_ts_lookahead_iterator_reset_state\"] = _ts_lookahead_iterator_reset_state = wasmExports2[\"ts_lookahead_iterator_reset_state\"];\n          Module[\"_ts_lookahead_iterator_reset\"] = _ts_lookahead_iterator_reset = wasmExports2[\"ts_lookahead_iterator_reset\"];\n          Module[\"_ts_lookahead_iterator_next\"] = _ts_lookahead_iterator_next = wasmExports2[\"ts_lookahead_iterator_next\"];\n          Module[\"_ts_lookahead_iterator_current_symbol\"] = _ts_lookahead_iterator_current_symbol = wasmExports2[\"ts_lookahead_iterator_current_symbol\"];\n          Module[\"_ts_point_edit\"] = _ts_point_edit = wasmExports2[\"ts_point_edit\"];\n          Module[\"_ts_parser_delete\"] = _ts_parser_delete = wasmExports2[\"ts_parser_delete\"];\n          Module[\"_ts_parser_reset\"] = _ts_parser_reset = wasmExports2[\"ts_parser_reset\"];\n          Module[\"_ts_parser_set_language\"] = _ts_parser_set_language = wasmExports2[\"ts_parser_set_language\"];\n          Module[\"_ts_parser_set_included_ranges\"] = _ts_parser_set_included_ranges = wasmExports2[\"ts_parser_set_included_ranges\"];\n          Module[\"_ts_query_new\"] = _ts_query_new = wasmExports2[\"ts_query_new\"];\n          Module[\"_ts_query_delete\"] = _ts_query_delete = wasmExports2[\"ts_query_delete\"];\n          Module[\"_iswspace\"] = _iswspace = wasmExports2[\"iswspace\"];\n          Module[\"_iswalnum\"] = _iswalnum = wasmExports2[\"iswalnum\"];\n          Module[\"_ts_query_pattern_count\"] = _ts_query_pattern_count = wasmExports2[\"ts_query_pattern_count\"];\n          Module[\"_ts_query_capture_count\"] = _ts_query_capture_count = wasmExports2[\"ts_query_capture_count\"];\n          Module[\"_ts_query_string_count\"] = _ts_query_string_count = wasmExports2[\"ts_query_string_count\"];\n          Module[\"_ts_query_capture_name_for_id\"] = _ts_query_capture_name_for_id = wasmExports2[\"ts_query_capture_name_for_id\"];\n          Module[\"_ts_query_capture_quantifier_for_id\"] = _ts_query_capture_quantifier_for_id = wasmExports2[\"ts_query_capture_quantifier_for_id\"];\n          Module[\"_ts_query_string_value_for_id\"] = _ts_query_string_value_for_id = wasmExports2[\"ts_query_string_value_for_id\"];\n          Module[\"_ts_query_predicates_for_pattern\"] = _ts_query_predicates_for_pattern = wasmExports2[\"ts_query_predicates_for_pattern\"];\n          Module[\"_ts_query_start_byte_for_pattern\"] = _ts_query_start_byte_for_pattern = wasmExports2[\"ts_query_start_byte_for_pattern\"];\n          Module[\"_ts_query_end_byte_for_pattern\"] = _ts_query_end_byte_for_pattern = wasmExports2[\"ts_query_end_byte_for_pattern\"];\n          Module[\"_ts_query_is_pattern_rooted\"] = _ts_query_is_pattern_rooted = wasmExports2[\"ts_query_is_pattern_rooted\"];\n          Module[\"_ts_query_is_pattern_non_local\"] = _ts_query_is_pattern_non_local = wasmExports2[\"ts_query_is_pattern_non_local\"];\n          Module[\"_ts_query_is_pattern_guaranteed_at_step\"] = _ts_query_is_pattern_guaranteed_at_step = wasmExports2[\"ts_query_is_pattern_guaranteed_at_step\"];\n          Module[\"_ts_query_disable_capture\"] = _ts_query_disable_capture = wasmExports2[\"ts_query_disable_capture\"];\n          Module[\"_ts_query_disable_pattern\"] = _ts_query_disable_pattern = wasmExports2[\"ts_query_disable_pattern\"];\n          Module[\"_ts_tree_copy\"] = _ts_tree_copy = wasmExports2[\"ts_tree_copy\"];\n          Module[\"_ts_tree_delete\"] = _ts_tree_delete = wasmExports2[\"ts_tree_delete\"];\n          Module[\"_ts_init\"] = _ts_init = wasmExports2[\"ts_init\"];\n          Module[\"_ts_parser_new_wasm\"] = _ts_parser_new_wasm = wasmExports2[\"ts_parser_new_wasm\"];\n          Module[\"_ts_parser_enable_logger_wasm\"] = _ts_parser_enable_logger_wasm = wasmExports2[\"ts_parser_enable_logger_wasm\"];\n          Module[\"_ts_parser_parse_wasm\"] = _ts_parser_parse_wasm = wasmExports2[\"ts_parser_parse_wasm\"];\n          Module[\"_ts_parser_included_ranges_wasm\"] = _ts_parser_included_ranges_wasm = wasmExports2[\"ts_parser_included_ranges_wasm\"];\n          Module[\"_ts_language_type_is_named_wasm\"] = _ts_language_type_is_named_wasm = wasmExports2[\"ts_language_type_is_named_wasm\"];\n          Module[\"_ts_language_type_is_visible_wasm\"] = _ts_language_type_is_visible_wasm = wasmExports2[\"ts_language_type_is_visible_wasm\"];\n          Module[\"_ts_language_metadata_wasm\"] = _ts_language_metadata_wasm = wasmExports2[\"ts_language_metadata_wasm\"];\n          Module[\"_ts_language_supertypes_wasm\"] = _ts_language_supertypes_wasm = wasmExports2[\"ts_language_supertypes_wasm\"];\n          Module[\"_ts_language_subtypes_wasm\"] = _ts_language_subtypes_wasm = wasmExports2[\"ts_language_subtypes_wasm\"];\n          Module[\"_ts_tree_root_node_wasm\"] = _ts_tree_root_node_wasm = wasmExports2[\"ts_tree_root_node_wasm\"];\n          Module[\"_ts_tree_root_node_with_offset_wasm\"] = _ts_tree_root_node_with_offset_wasm = wasmExports2[\"ts_tree_root_node_with_offset_wasm\"];\n          Module[\"_ts_tree_edit_wasm\"] = _ts_tree_edit_wasm = wasmExports2[\"ts_tree_edit_wasm\"];\n          Module[\"_ts_tree_included_ranges_wasm\"] = _ts_tree_included_ranges_wasm = wasmExports2[\"ts_tree_included_ranges_wasm\"];\n          Module[\"_ts_tree_get_changed_ranges_wasm\"] = _ts_tree_get_changed_ranges_wasm = wasmExports2[\"ts_tree_get_changed_ranges_wasm\"];\n          Module[\"_ts_tree_cursor_new_wasm\"] = _ts_tree_cursor_new_wasm = wasmExports2[\"ts_tree_cursor_new_wasm\"];\n          Module[\"_ts_tree_cursor_copy_wasm\"] = _ts_tree_cursor_copy_wasm = wasmExports2[\"ts_tree_cursor_copy_wasm\"];\n          Module[\"_ts_tree_cursor_delete_wasm\"] = _ts_tree_cursor_delete_wasm = wasmExports2[\"ts_tree_cursor_delete_wasm\"];\n          Module[\"_ts_tree_cursor_reset_wasm\"] = _ts_tree_cursor_reset_wasm = wasmExports2[\"ts_tree_cursor_reset_wasm\"];\n          Module[\"_ts_tree_cursor_reset_to_wasm\"] = _ts_tree_cursor_reset_to_wasm = wasmExports2[\"ts_tree_cursor_reset_to_wasm\"];\n          Module[\"_ts_tree_cursor_goto_first_child_wasm\"] = _ts_tree_cursor_goto_first_child_wasm = wasmExports2[\"ts_tree_cursor_goto_first_child_wasm\"];\n          Module[\"_ts_tree_cursor_goto_last_child_wasm\"] = _ts_tree_cursor_goto_last_child_wasm = wasmExports2[\"ts_tree_cursor_goto_last_child_wasm\"];\n          Module[\"_ts_tree_cursor_goto_first_child_for_index_wasm\"] = _ts_tree_cursor_goto_first_child_for_index_wasm = wasmExports2[\"ts_tree_cursor_goto_first_child_for_index_wasm\"];\n          Module[\"_ts_tree_cursor_goto_first_child_for_position_wasm\"] = _ts_tree_cursor_goto_first_child_for_position_wasm = wasmExports2[\"ts_tree_cursor_goto_first_child_for_position_wasm\"];\n          Module[\"_ts_tree_cursor_goto_next_sibling_wasm\"] = _ts_tree_cursor_goto_next_sibling_wasm = wasmExports2[\"ts_tree_cursor_goto_next_sibling_wasm\"];\n          Module[\"_ts_tree_cursor_goto_previous_sibling_wasm\"] = _ts_tree_cursor_goto_previous_sibling_wasm = wasmExports2[\"ts_tree_cursor_goto_previous_sibling_wasm\"];\n          Module[\"_ts_tree_cursor_goto_descendant_wasm\"] = _ts_tree_cursor_goto_descendant_wasm = wasmExports2[\"ts_tree_cursor_goto_descendant_wasm\"];\n          Module[\"_ts_tree_cursor_goto_parent_wasm\"] = _ts_tree_cursor_goto_parent_wasm = wasmExports2[\"ts_tree_cursor_goto_parent_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_type_id_wasm\"] = _ts_tree_cursor_current_node_type_id_wasm = wasmExports2[\"ts_tree_cursor_current_node_type_id_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_state_id_wasm\"] = _ts_tree_cursor_current_node_state_id_wasm = wasmExports2[\"ts_tree_cursor_current_node_state_id_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_is_named_wasm\"] = _ts_tree_cursor_current_node_is_named_wasm = wasmExports2[\"ts_tree_cursor_current_node_is_named_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_is_missing_wasm\"] = _ts_tree_cursor_current_node_is_missing_wasm = wasmExports2[\"ts_tree_cursor_current_node_is_missing_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_id_wasm\"] = _ts_tree_cursor_current_node_id_wasm = wasmExports2[\"ts_tree_cursor_current_node_id_wasm\"];\n          Module[\"_ts_tree_cursor_start_position_wasm\"] = _ts_tree_cursor_start_position_wasm = wasmExports2[\"ts_tree_cursor_start_position_wasm\"];\n          Module[\"_ts_tree_cursor_end_position_wasm\"] = _ts_tree_cursor_end_position_wasm = wasmExports2[\"ts_tree_cursor_end_position_wasm\"];\n          Module[\"_ts_tree_cursor_start_index_wasm\"] = _ts_tree_cursor_start_index_wasm = wasmExports2[\"ts_tree_cursor_start_index_wasm\"];\n          Module[\"_ts_tree_cursor_end_index_wasm\"] = _ts_tree_cursor_end_index_wasm = wasmExports2[\"ts_tree_cursor_end_index_wasm\"];\n          Module[\"_ts_tree_cursor_current_field_id_wasm\"] = _ts_tree_cursor_current_field_id_wasm = wasmExports2[\"ts_tree_cursor_current_field_id_wasm\"];\n          Module[\"_ts_tree_cursor_current_depth_wasm\"] = _ts_tree_cursor_current_depth_wasm = wasmExports2[\"ts_tree_cursor_current_depth_wasm\"];\n          Module[\"_ts_tree_cursor_current_descendant_index_wasm\"] = _ts_tree_cursor_current_descendant_index_wasm = wasmExports2[\"ts_tree_cursor_current_descendant_index_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_wasm\"] = _ts_tree_cursor_current_node_wasm = wasmExports2[\"ts_tree_cursor_current_node_wasm\"];\n          Module[\"_ts_node_symbol_wasm\"] = _ts_node_symbol_wasm = wasmExports2[\"ts_node_symbol_wasm\"];\n          Module[\"_ts_node_field_name_for_child_wasm\"] = _ts_node_field_name_for_child_wasm = wasmExports2[\"ts_node_field_name_for_child_wasm\"];\n          Module[\"_ts_node_field_name_for_named_child_wasm\"] = _ts_node_field_name_for_named_child_wasm = wasmExports2[\"ts_node_field_name_for_named_child_wasm\"];\n          Module[\"_ts_node_children_by_field_id_wasm\"] = _ts_node_children_by_field_id_wasm = wasmExports2[\"ts_node_children_by_field_id_wasm\"];\n          Module[\"_ts_node_first_child_for_byte_wasm\"] = _ts_node_first_child_for_byte_wasm = wasmExports2[\"ts_node_first_child_for_byte_wasm\"];\n          Module[\"_ts_node_first_named_child_for_byte_wasm\"] = _ts_node_first_named_child_for_byte_wasm = wasmExports2[\"ts_node_first_named_child_for_byte_wasm\"];\n          Module[\"_ts_node_grammar_symbol_wasm\"] = _ts_node_grammar_symbol_wasm = wasmExports2[\"ts_node_grammar_symbol_wasm\"];\n          Module[\"_ts_node_child_count_wasm\"] = _ts_node_child_count_wasm = wasmExports2[\"ts_node_child_count_wasm\"];\n          Module[\"_ts_node_named_child_count_wasm\"] = _ts_node_named_child_count_wasm = wasmExports2[\"ts_node_named_child_count_wasm\"];\n          Module[\"_ts_node_child_wasm\"] = _ts_node_child_wasm = wasmExports2[\"ts_node_child_wasm\"];\n          Module[\"_ts_node_named_child_wasm\"] = _ts_node_named_child_wasm = wasmExports2[\"ts_node_named_child_wasm\"];\n          Module[\"_ts_node_child_by_field_id_wasm\"] = _ts_node_child_by_field_id_wasm = wasmExports2[\"ts_node_child_by_field_id_wasm\"];\n          Module[\"_ts_node_next_sibling_wasm\"] = _ts_node_next_sibling_wasm = wasmExports2[\"ts_node_next_sibling_wasm\"];\n          Module[\"_ts_node_prev_sibling_wasm\"] = _ts_node_prev_sibling_wasm = wasmExports2[\"ts_node_prev_sibling_wasm\"];\n          Module[\"_ts_node_next_named_sibling_wasm\"] = _ts_node_next_named_sibling_wasm = wasmExports2[\"ts_node_next_named_sibling_wasm\"];\n          Module[\"_ts_node_prev_named_sibling_wasm\"] = _ts_node_prev_named_sibling_wasm = wasmExports2[\"ts_node_prev_named_sibling_wasm\"];\n          Module[\"_ts_node_descendant_count_wasm\"] = _ts_node_descendant_count_wasm = wasmExports2[\"ts_node_descendant_count_wasm\"];\n          Module[\"_ts_node_parent_wasm\"] = _ts_node_parent_wasm = wasmExports2[\"ts_node_parent_wasm\"];\n          Module[\"_ts_node_child_with_descendant_wasm\"] = _ts_node_child_with_descendant_wasm = wasmExports2[\"ts_node_child_with_descendant_wasm\"];\n          Module[\"_ts_node_descendant_for_index_wasm\"] = _ts_node_descendant_for_index_wasm = wasmExports2[\"ts_node_descendant_for_index_wasm\"];\n          Module[\"_ts_node_named_descendant_for_index_wasm\"] = _ts_node_named_descendant_for_index_wasm = wasmExports2[\"ts_node_named_descendant_for_index_wasm\"];\n          Module[\"_ts_node_descendant_for_position_wasm\"] = _ts_node_descendant_for_position_wasm = wasmExports2[\"ts_node_descendant_for_position_wasm\"];\n          Module[\"_ts_node_named_descendant_for_position_wasm\"] = _ts_node_named_descendant_for_position_wasm = wasmExports2[\"ts_node_named_descendant_for_position_wasm\"];\n          Module[\"_ts_node_start_point_wasm\"] = _ts_node_start_point_wasm = wasmExports2[\"ts_node_start_point_wasm\"];\n          Module[\"_ts_node_end_point_wasm\"] = _ts_node_end_point_wasm = wasmExports2[\"ts_node_end_point_wasm\"];\n          Module[\"_ts_node_start_index_wasm\"] = _ts_node_start_index_wasm = wasmExports2[\"ts_node_start_index_wasm\"];\n          Module[\"_ts_node_end_index_wasm\"] = _ts_node_end_index_wasm = wasmExports2[\"ts_node_end_index_wasm\"];\n          Module[\"_ts_node_to_string_wasm\"] = _ts_node_to_string_wasm = wasmExports2[\"ts_node_to_string_wasm\"];\n          Module[\"_ts_node_children_wasm\"] = _ts_node_children_wasm = wasmExports2[\"ts_node_children_wasm\"];\n          Module[\"_ts_node_named_children_wasm\"] = _ts_node_named_children_wasm = wasmExports2[\"ts_node_named_children_wasm\"];\n          Module[\"_ts_node_descendants_of_type_wasm\"] = _ts_node_descendants_of_type_wasm = wasmExports2[\"ts_node_descendants_of_type_wasm\"];\n          Module[\"_ts_node_is_named_wasm\"] = _ts_node_is_named_wasm = wasmExports2[\"ts_node_is_named_wasm\"];\n          Module[\"_ts_node_has_changes_wasm\"] = _ts_node_has_changes_wasm = wasmExports2[\"ts_node_has_changes_wasm\"];\n          Module[\"_ts_node_has_error_wasm\"] = _ts_node_has_error_wasm = wasmExports2[\"ts_node_has_error_wasm\"];\n          Module[\"_ts_node_is_error_wasm\"] = _ts_node_is_error_wasm = wasmExports2[\"ts_node_is_error_wasm\"];\n          Module[\"_ts_node_is_missing_wasm\"] = _ts_node_is_missing_wasm = wasmExports2[\"ts_node_is_missing_wasm\"];\n          Module[\"_ts_node_is_extra_wasm\"] = _ts_node_is_extra_wasm = wasmExports2[\"ts_node_is_extra_wasm\"];\n          Module[\"_ts_node_parse_state_wasm\"] = _ts_node_parse_state_wasm = wasmExports2[\"ts_node_parse_state_wasm\"];\n          Module[\"_ts_node_next_parse_state_wasm\"] = _ts_node_next_parse_state_wasm = wasmExports2[\"ts_node_next_parse_state_wasm\"];\n          Module[\"_ts_query_matches_wasm\"] = _ts_query_matches_wasm = wasmExports2[\"ts_query_matches_wasm\"];\n          Module[\"_ts_query_captures_wasm\"] = _ts_query_captures_wasm = wasmExports2[\"ts_query_captures_wasm\"];\n          Module[\"_memset\"] = _memset = wasmExports2[\"memset\"];\n          Module[\"_memcpy\"] = _memcpy = wasmExports2[\"memcpy\"];\n          Module[\"_memmove\"] = _memmove = wasmExports2[\"memmove\"];\n          Module[\"_iswalpha\"] = _iswalpha = wasmExports2[\"iswalpha\"];\n          Module[\"_iswblank\"] = _iswblank = wasmExports2[\"iswblank\"];\n          Module[\"_iswdigit\"] = _iswdigit = wasmExports2[\"iswdigit\"];\n          Module[\"_iswlower\"] = _iswlower = wasmExports2[\"iswlower\"];\n          Module[\"_iswupper\"] = _iswupper = wasmExports2[\"iswupper\"];\n          Module[\"_iswxdigit\"] = _iswxdigit = wasmExports2[\"iswxdigit\"];\n          Module[\"_memchr\"] = _memchr = wasmExports2[\"memchr\"];\n          Module[\"_strlen\"] = _strlen = wasmExports2[\"strlen\"];\n          Module[\"_strcmp\"] = _strcmp = wasmExports2[\"strcmp\"];\n          Module[\"_strncat\"] = _strncat = wasmExports2[\"strncat\"];\n          Module[\"_strncpy\"] = _strncpy = wasmExports2[\"strncpy\"];\n          Module[\"_towlower\"] = _towlower = wasmExports2[\"towlower\"];\n          Module[\"_towupper\"] = _towupper = wasmExports2[\"towupper\"];\n          _setThrew = wasmExports2[\"setThrew\"];\n          __emscripten_stack_restore = wasmExports2[\"_emscripten_stack_restore\"];\n          __emscripten_stack_alloc = wasmExports2[\"_emscripten_stack_alloc\"];\n          _emscripten_stack_get_current = wasmExports2[\"emscripten_stack_get_current\"];\n          ___wasm_apply_data_relocs = wasmExports2[\"__wasm_apply_data_relocs\"];\n        }\n        __name(assignWasmExports, \"assignWasmExports\");\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_high: ___stack_high,\n          /** @export */\n          __stack_low: ___stack_low,\n          /** @export */\n          __stack_pointer: ___stack_pointer,\n          /** @export */\n          __table_base: ___table_base,\n          /** @export */\n          _abort_js: __abort_js,\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        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\"] || false;\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        var wasmExports;\n        wasmExports = await createWasm();\n        run();\n        if (runtimeInitialized) {\n          moduleRtn = Module;\n        } else {\n          moduleRtn = new Promise((resolve, reject) => {\n            readyPromiseResolve = resolve;\n            readyPromiseReject = reject;\n          });\n        }\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  Edit: () => Edit,\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/edit.ts\nvar Edit = class {\n  static {\n    __name(this, \"Edit\");\n  }\n  /** The start position of the change. */\n  startPosition;\n  /** The end position of the change before the edit. */\n  oldEndPosition;\n  /** The end position of the change after the edit. */\n  newEndPosition;\n  /** The start index of the change. */\n  startIndex;\n  /** The end index of the change before the edit. */\n  oldEndIndex;\n  /** The end index of the change after the edit. */\n  newEndIndex;\n  constructor({\n    startIndex,\n    oldEndIndex,\n    newEndIndex,\n    startPosition,\n    oldEndPosition,\n    newEndPosition\n  }) {\n    this.startIndex = startIndex >>> 0;\n    this.oldEndIndex = oldEndIndex >>> 0;\n    this.newEndIndex = newEndIndex >>> 0;\n    this.startPosition = startPosition;\n    this.oldEndPosition = oldEndPosition;\n    this.newEndPosition = newEndPosition;\n  }\n  /**\n   * Edit a point and index to keep it in-sync with source code that has been edited.\n   *\n   * This function updates a single point's byte offset and row/column position\n   * based on an edit operation. This is useful for editing points without\n   * requiring a tree or node instance.\n   */\n  editPoint(point, index) {\n    let newIndex = index;\n    const newPoint = { ...point };\n    if (index >= this.oldEndIndex) {\n      newIndex = this.newEndIndex + (index - this.oldEndIndex);\n      const originalRow = point.row;\n      newPoint.row = this.newEndPosition.row + (point.row - this.oldEndPosition.row);\n      newPoint.column = originalRow === this.oldEndPosition.row ? this.newEndPosition.column + (point.column - this.oldEndPosition.column) : point.column;\n    } else if (index > this.startIndex) {\n      newIndex = this.newEndIndex;\n      newPoint.row = this.newEndPosition.row;\n      newPoint.column = this.newEndPosition.column;\n    }\n    return { point: newPoint, index: newIndex };\n  }\n  /**\n   * Edit a range to keep it in-sync with source code that has been edited.\n   *\n   * This function updates a range's start and end positions based on an edit\n   * operation. This is useful for editing ranges without requiring a tree\n   * or node instance.\n   */\n  editRange(range) {\n    const newRange = {\n      startIndex: range.startIndex,\n      startPosition: { ...range.startPosition },\n      endIndex: range.endIndex,\n      endPosition: { ...range.endPosition }\n    };\n    if (range.endIndex >= this.oldEndIndex) {\n      if (range.endIndex !== Number.MAX_SAFE_INTEGER) {\n        newRange.endIndex = this.newEndIndex + (range.endIndex - this.oldEndIndex);\n        newRange.endPosition = {\n          row: this.newEndPosition.row + (range.endPosition.row - this.oldEndPosition.row),\n          column: range.endPosition.row === this.oldEndPosition.row ? this.newEndPosition.column + (range.endPosition.column - this.oldEndPosition.column) : range.endPosition.column\n        };\n        if (newRange.endIndex < this.newEndIndex) {\n          newRange.endIndex = Number.MAX_SAFE_INTEGER;\n          newRange.endPosition = { row: Number.MAX_SAFE_INTEGER, column: Number.MAX_SAFE_INTEGER };\n        }\n      }\n    } else if (range.endIndex > this.startIndex) {\n      newRange.endIndex = this.startIndex;\n      newRange.endPosition = { ...this.startPosition };\n    }\n    if (range.startIndex >= this.oldEndIndex) {\n      newRange.startIndex = this.newEndIndex + (range.startIndex - this.oldEndIndex);\n      newRange.startPosition = {\n        row: this.newEndPosition.row + (range.startPosition.row - this.oldEndPosition.row),\n        column: range.startPosition.row === this.oldEndPosition.row ? this.newEndPosition.column + (range.startPosition.column - this.oldEndPosition.column) : range.startPosition.column\n      };\n      if (newRange.startIndex < this.newEndIndex) {\n        newRange.startIndex = Number.MAX_SAFE_INTEGER;\n        newRange.startPosition = { row: Number.MAX_SAFE_INTEGER, column: Number.MAX_SAFE_INTEGER };\n      }\n    } else if (range.startIndex > this.startIndex) {\n      newRange.startIndex = this.startIndex;\n      newRange.startPosition = { ...this.startPosition };\n    }\n    return newRange;\n  }\n};\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 = /* @__PURE__ */ 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  // @ts-expect-error: never read\n  [0] = 0;\n  // Internal handle for Wasm\n  /** @internal */\n  // @ts-expect-error: never read\n  [1] = 0;\n  // Internal handle for Wasm\n  /** @internal */\n  // @ts-expect-error: never read\n  [2] = 0;\n  // Internal handle for Wasm\n  /** @internal */\n  // @ts-expect-error: never read\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  // @ts-expect-error: never read\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 major_version = C.getValue(address, \"i32\");\n  const minor_version = C.getValue(address += SIZE_OF_INT, \"i32\");\n  const patch_version = C.getValue(address += SIZE_OF_INT, \"i32\");\n  return { major_version, minor_version, patch_version };\n}\n__name(unmarshalLanguageMetadata, \"unmarshalLanguageMetadata\");\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   * 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_wasm(this[0]);\n    const length = C.getValue(TRANSFER_BUFFER, \"i32\");\n    if (length === 0) return null;\n    return unmarshalLanguageMetadata(TRANSFER_BUFFER + SIZE_OF_INT);\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   * 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 binary2;\n    if (input instanceof Uint8Array) {\n      binary2 = input;\n    } else if (globalThis.process?.versions.node) {\n      const fs2 = await import(\"fs/promises\");\n      binary2 = await fs2.readFile(input);\n    } else {\n      const response = await fetch(input);\n      if (!response.ok) {\n        const body2 = await response.text();\n        throw new Error(`Language.load failed with status ${response.status}.\n\n${body2}`);\n      }\n      const retryResp = response.clone();\n      try {\n        binary2 = await WebAssembly.compileStreaming(response);\n      } catch (reason) {\n        console.error(\"wasm streaming compile failed:\", reason);\n        console.error(\"falling back to ArrayBuffer instantiation\");\n        binary2 = new Uint8Array(await retryResp.arrayBuffer());\n      }\n    }\n    const mod = await C.loadWebAssemblyModule(binary2, { 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_web_tree_sitter = __toESM(require_web_tree_sitter(), 1);\nvar Module2 = null;\nasync function initializeBinding(moduleOptions) {\n  return Module2 ??= await (0, import_web_tree_sitter.default)(moduleOptions);\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_abi_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 callback, \n   * 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  /** 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\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 startContainingPosition = options.startContainingPosition ?? ZERO_POINT;\n    const endContainingPosition = options.endContainingPosition ?? ZERO_POINT;\n    const startContainingIndex = options.startContainingIndex ?? 0;\n    const endContainingIndex = options.endContainingIndex ?? 0;\n    const matchLimit = options.matchLimit ?? 4294967295;\n    const maxStartDepth = options.maxStartDepth ?? 4294967295;\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 (endContainingIndex !== 0 && startContainingIndex > endContainingIndex) {\n      throw new Error(\"`startContainingIndex` cannot be greater than `endContainingIndex`\");\n    }\n    if (endContainingPosition !== ZERO_POINT && (startContainingPosition.row > endContainingPosition.row || startContainingPosition.row === endContainingPosition.row && startContainingPosition.column > endContainingPosition.column)) {\n      throw new Error(\"`startContainingPosition` cannot be greater than `endContainingPosition`\");\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      startContainingPosition.row,\n      startContainingPosition.column,\n      endContainingPosition.row,\n      endContainingPosition.column,\n      startContainingIndex,\n      endContainingIndex,\n      matchLimit,\n      maxStartDepth\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] = { 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 startContainingPosition = options.startContainingPosition ?? ZERO_POINT;\n    const endContainingPosition = options.endContainingPosition ?? ZERO_POINT;\n    const startContainingIndex = options.startContainingIndex ?? 0;\n    const endContainingIndex = options.endContainingIndex ?? 0;\n    const matchLimit = options.matchLimit ?? 4294967295;\n    const maxStartDepth = options.maxStartDepth ?? 4294967295;\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 (endContainingIndex !== 0 && startContainingIndex > endContainingIndex) {\n      throw new Error(\"`startContainingIndex` cannot be greater than `endContainingIndex`\");\n    }\n    if (endContainingPosition !== ZERO_POINT && (startContainingPosition.row > endContainingPosition.row || startContainingPosition.row === endContainingPosition.row && startContainingPosition.column > endContainingPosition.column)) {\n      throw new Error(\"`startContainingPosition` cannot be greater than `endContainingPosition`\");\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      startContainingPosition.row,\n      startContainingPosition.column,\n      endContainingPosition.row,\n      endContainingPosition.column,\n      startContainingIndex,\n      endContainingIndex,\n      matchLimit,\n      maxStartDepth\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// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  CaptureQuantifier,\n  Edit,\n  LANGUAGE_VERSION,\n  Language,\n  LookaheadIterator,\n  MIN_COMPATIBLE_VERSION,\n  Node,\n  Parser,\n  Query,\n  Tree,\n  TreeCursor\n});\nmodule.exports.default = module.exports;\n//# sourceMappingURL=web-tree-sitter.cjs.map\n","// The module cache\nconst __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tconst 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\tconst 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","const getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nlet 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\tconst ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tconst 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/value functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tif(Array.isArray(definition)) {\n\t\tvar i = 0;\n\t\twhile(i < definition.length) {\n\t\t\tvar key = definition[i++];\n\t\t\tvar binding = definition[i++];\n\t\t\tif(!__webpack_require__.o(exports, key)) {\n\t\t\t\tif(binding === 0) {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, value: definition[i++] });\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: binding });\n\t\t\t\t}\n\t\t\t} else if(binding === 0) { i++; }\n\t\t}\n\t} else {\n\t\tfor(var key in definition) {\n\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t\t}\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(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\nlet __webpack_exports__ = __webpack_require__(186);\n"],"names":["fs","__importStar","__webpack_require__","path","Parser","Language","analyze_1","nesting_1","cyclomatic_1","cognitive_1","languages_1","types_1","printUsage","console","error","resolveThresholdOverride","override","defaults","undefined","mediumThreshold","highThreshold","async","parsed","argv","flag","name","index","indexOf","Number","filePath","find","arg","startsWith","nesting","cyclomatic","cognitive","parseArgs","process","slice","exit","adapter","resolveLanguageForFile","sourceCode","readFileSync","tree","init","parser","grammarPath","join","__dirname","grammar","load","setLanguage","loadParser","parse","violations","analyzeSource","DEFAULT_NESTING_THRESHOLDS","DEFAULT_CYCLOMATIC_THRESHOLDS","DEFAULT_COGNITIVE_THRESHOLDS","buildThresholds","log","JSON","stringify","hasBlockingViolation","some","v","severity","SEVERITY","HIGH","MEDIUM","main","catch","exports","sourceText","language","fileName","thresholds","positions","position_1","createPositionLookup","push","analyzeNesting","analyzeFunctionComplexity","analyzeCognitiveComplexity","coherence_1","analyzeFileCoherence","coherence","DEFAULT_COHERENCE_THRESHOLDS","magicNumber_1","analyzeMagicNumbers","magicNumber","DEFAULT_MAGIC_NUMBER_OPTIONS","magicString_1","analyzeMagicStrings","magicString","DEFAULT_MAGIC_STRING_OPTIONS","parameterCount_1","analyzeParameterCount","inversion_1","analyzeInversionOpportunities","primitiveObsession_1","analyzePrimitiveObsession","matchOpportunity_1","analyzeMatchOpportunities","matchOpportunity","DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS","logicalControlFlow_1","analyzeLogicalControlFlow","opaqueBoolean_1","analyzeOpaqueBooleanLiteral","traverse","node","isFunctionDefinition","complexity","calculateCognitiveComplexity","position","toPosition","startIndex","line","column","type","VIOLATION_TYPE","COGNITIVE","message","hotspots","findCognitiveHotspots","child","children","rootNode","functionNode","onContribution","score","nodeTypes","add","amount","walkNested","walk","entersNestedScope","booleanOperator","getBooleanOperator","parent","cognitiveNestedDecisionTypes","includes","elseClause","conditionalExpression","lambda","weight","functions","imports","importStatement","importFromStatement","text","collectFunctionsAndImports","checkFunctionCountSprawl","checkLargeFunctionSprawl","checkImportSprawl","filter","violation","leadingNameWord","nameNode","c","match","exec","toLowerCase","length","baseName","split","pop","isUtilsFile","singleDomain","minShare","leadingWords","map","word","wordCounts","Map","set","get","Math","max","values","looksLikeSingleDomain","singleDomainNameShare","COHERENCE","largeFunctions","fn","lineCount","endPosition","row","startPosition","largeFunctionLines","maxLargeFunctions","countDecisionPoints","isRoot","decisionNodeTypes","isTryElseClause","calculateCyclomaticComplexity","COMPLEXITY","findCyclomaticHotspots","depth","nextDepth","body","block","statements","isNamed","comment","trim","firstStatement","ifStatement","ifBody","totalLines","endIndex","INVERSION","currentNode","nestingLevel","validationChecks","nestingControlTypes","firstCheck","analyzeNestedValidation","maxNesting","nestedIfLocation","countNesting","currentDepth","analyzeNestedIfs","analyzeFunction","operator","expressionStatement","LOGICAL_CONTROL_FLOW","LOW","options","enabled","hasEnclosingFunction","assignmentNode","ancestor","integerLiteral","floatLiteral","rawValue","parseFloat","isNaN","value","signedValue","allowlist","assignment","grandparent","module","exportStatement","isInConstantContext","subscriptNodeTypes","isIndexPosition","isDefaultParameterValue","MAGIC","candidates","stringLiteral","content","Boolean","candidate","getEqualityComparisons","left","right","id","isEqualityComparisonOperand","container","getMembershipComparisons","isMembershipOperand","isKeyOrIndexPosition","isDecisionPoint","isDocstring","isFormattedOrInterpolatedString","isExempt","byContent","group","minDuplicates","first","consumed","Set","has","topIfNode","branches","ifNode","flatSiblings","getElseIfBranches","current","nestedIf","collectChainBranches","forEach","branch","minBranches","perBranchDiscriminants","branchNode","otherBranches","found","isVariableRef","variableReferenceNodeTypes","isLiteral","literalValue","variable","collectBranchDiscriminants","b","discriminants","commonVariable","d","every","MATCH_OPPORTUNITY","analyzeChain","NESTING","isBooleanLiteral","isPositionalCallArgument","OPAQUE_BOOLEAN","buildViolation","findParametersNode","params","parameters","paramCount","parameterChildTypes","PARAMETERS","parametersType","paramsNode","keywordOnly","typed","n","keywordOnlyBoundaryTypes","extracted","extractTypedParameter","i","a","primitiveTypeNames","PRIMITIVE_OBSESSION","distinctTypeAdvice","findParameterCollisions","valuesByVariable","firstOccurrence","record","varNode","key","stripQuotes","size","sample","Array","from","findStringlyTypedControlFlow","lineStartOffsets","offset","low","high","mid","ceil","FSHARP","forStatement","whileStatement","opToken","patternNode","typeNode","operands","rawRight","dotIndex","lastIndexOf","extension","languageId","EXTENSION_TO_LANGUAGE_ID","Y","python_1","fsharp_1","typescript_1","python","PYTHON","fsharp","typescript","TYPESCRIPT","results","allStrings","methodName","typeAnnotation","NAMING","require","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","__create","Object","create","__defProp","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__getProtoOf","getPrototypeOf","__hasOwnProp","prototype","hasOwnProperty","__name","target","configurable","__commonJS","cb","mod","__export","all","name2","enumerable","__copyProps","to","except","desc","call","__toESM","isNodeMode","__esModule","__toCommonJS","require_web_tree_sitter","Module","_scriptName","document","currentScript","src","moduleArg","moduleRtn","ENVIRONMENT_IS_WEB","window","ENVIRONMENT_IS_WORKER","WorkerGlobalScope","ENVIRONMENT_IS_NODE","versions","currentQueryProgressCallback","currentProgressCallback","currentLogCallback","currentParseCallback","arguments_","thisProgram","quit_","status","toThrow","__filename","scriptDirectory","readAsync","readBinary","locateFile","filename","isFileURI","URL","binary2","replace","exitCode","href","url","xhr","XMLHttpRequest","open","responseType","send","Uint8Array","response","Promise","resolve","reject","onload","onerror","fetch","credentials","ok","arrayBuffer","Error","out","bind","err","dynamicLibraries","wasmBinary","ABORT","EXITSTATUS","readyPromiseResolve","readyPromiseReject","wasmMemory","HEAP8","HEAPU8","HEAP16","HEAPU16","HEAP32","HEAPU32","HEAPF32","HEAPF64","HEAP64","HEAPU64","HEAP_DATA_VIEW","runtimeInitialized","updateMemoryViews","buffer","Int8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","BigInt64Array","BigUint64Array","DataView","LE_HEAP_UPDATE","initMemory","INITIAL_MEMORY","WebAssembly","Memory","initial","maximum","__RELOC_FUNCS__","wasmBinaryFile","preRun","addOnPreRun","shift","callRuntimeCallbacks","onPreRuns","initRuntime","wasmExports","onPostCtors","preMain","postRun","addOnPostRun","onPostRuns","abort","what","e","RuntimeError","findWasmBinary","getBinarySync","file","getWasmBinary","binaryFile","instantiateArrayBuffer","instantiate","reason","instantiateAsync","instantiateStreaming","getWasmImports","env","wasmImports","wasi_snapshot_preview1","Proxy","GOTHandler","createWasm","receiveInstance","instance2","module2","relocateExports","metadata2","getDylinkMetadata","neededDynlibs","concat","mergeLibSymbols","LDSO","loadDylibs","assignWasmExports","receiveInstantiationResult","result2","info2","inst","ExitStatus","this","constructor","GOT","currentModuleWeakSymbols","obj","symName","rtn","Global","mutable","required","LE_ATOMICS_NATIVE_BYTE_ORDER","LE_HEAP_LOAD_F32","byteOffset","getFloat32","LE_HEAP_LOAD_F64","getFloat64","LE_HEAP_LOAD_I16","getInt16","LE_HEAP_LOAD_I32","getInt32","LE_HEAP_LOAD_I64","getBigInt64","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_I64","setBigInt64","LE_HEAP_STORE_U32","setUint32","callbacks","UTF8Decoder","TextDecoder","findStringEnd","heapOrArray","idx","maxBytesToRead","ignoreNul","maxIdx","UTF8ArrayToString","endPtr","decode","subarray","str","u0","u1","u2","String","fromCharCode","ch","end","getU8","getLEB","ret","mul","byte","getString","len","getStringList","count2","failIf","condition","dylinkSection","customSections","int32View","section_size","customSection","tlsExports","weakImports","runtimePaths","subsectionType","subsectionSize","memorySize","memoryAlign","tableSize","tableAlign","count","symname","getValue","ptr","endsWith","newDSO","handle2","syms","dso","refcount","Infinity","global","loadedLibsByName","loadedLibsByHandle","___heap_base","alignMemory","alignment","getMemory","_calloc","isInternalSym","uleb128EncodeWithLen","arr","wasmTypeCodes","p","j","f","generateTypePack","types","convertJsFunctionToWasm","func2","sig","bytes","of","Instance","wasmTableMirror","wasmTable","Table","element","getWasmTableEntry","funcPtr","updateTableMap","functionsInTableMap","i2","item","getFunctionAddress","WeakMap","freeTableIndexes","getEmptyTableSlot","setWasmTableEntry","addFunction","err2","TypeError","wrapped","updateGOT","exports2","memoryBase2","relocated","isSymbolDefined","existing","stub","dynCall","args2","promising","rtn2","stackSave","_emscripten_stack_get_current","stackRestore","val","__emscripten_stack_restore","createInvokeFunction","sp","_setThrew","resolveGlobalSymbol","direct","sym","addOnPostCtor","UTF8ToString","loadWebAssemblyModule","binary","flags","libName","localScope","handle","metadata","loadModule","memAlign","pow","memoryBase","tableBase","moduleExports","resolveSymbol","resolved","grow","proxyHandler","stubs","prop","proxy","info","postInstantiation","instance","addEmAsm","addr","args","arity","func","ASM_CONSTS","start","eval","allowUndefined","reportUndefinedSymbols","stop","jsString","addEmJs","cSig","jsArgs","jsArg","parts","applyRelocs","loadAsync","rpath","parentLibPath","paths","reduce","chain","dynNeeded","then","loadDynamicLibrary","needed","libName2","exp","entries","setImport","main_alias","asyncLoad","flags2","nodelete","localScope2","assign","loadLibData","data","dataSize","libData","libFile","getExports","moduleLoaded","entry","runDependencies","dependenciesFulfilled","removeRunDependency","callback","addRunDependency","lib","noExitRuntime","setValue","BigInt","___memory_base","___stack_high","___stack_low","___stack_pointer","___table_base","__abort_js","getHeapMax","growMemory","pages","byteLength","_emscripten_resize_heap","requestedSize","oldSize","maxHeapSize","cutDown","overGrownHeapSize","min","newSize","_fd_close","fd","INT53_MAX","INT53_MIN","bigintToI53Checked","num","NaN","_fd_seek","whence","newOffset","printCharBuffers","printChar","stream","curr","_fd_write","iov","iovcnt","pnum","_tree_sitter_log_callback","isLexMessage","messageAddress","_tree_sitter_parse_callback","inputBufferAddress","lengthAddress","string","stringToUTF16","_tree_sitter_progress_callback","currentOffset","hasError","_tree_sitter_query_progress_callback","runtimeKeepaliveCounter","keepRuntimeAlive","_proc_exit","code","exitJS","implicit","handleException","lengthBytesUTF8","charCodeAt","stringToUTF8Array","heap","outIdx","maxBytesToWrite","startIdx","endIdx","u","codePointAt","stringToUTF8","outPtr","stackAlloc","sz","__emscripten_stack_alloc","stringToUTF8OnStack","AsciiToString","startPtr","numCharsToWrite","codeUnit","unsigned","x","_malloc","_realloc","_free","_ts_range_edit","_memcmp","_ts_language_symbol_count","_ts_language_state_count","_ts_language_abi_version","_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_point_edit","_ts_parser_delete","_ts_parser_reset","_ts_parser_set_language","_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_metadata_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","wasmExports2","__heap_base","__indirect_function_table","__memory_base","__stack_high","__stack_low","__stack_pointer","__table_base","_abort_js","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","callMain","entryFunction","unshift","argc","argv_ptr","run","doRun","setTimeout","default","apply","index_exports","CaptureQuantifier","Edit","LANGUAGE_VERSION","LookaheadIterator","MIN_COMPATIBLE_VERSION","Node","Query","Tree","TreeCursor","oldEndPosition","newEndPosition","oldEndIndex","newEndIndex","editPoint","point","newIndex","newPoint","originalRow","editRange","range","newRange","MAX_SAFE_INTEGER","SIZE_OF_SHORT","SIZE_OF_INT","SIZE_OF_CURSOR","SIZE_OF_NODE","SIZE_OF_POINT","SIZE_OF_RANGE","ZERO_POINT","INTERNAL","Symbol","C","assertInternal","isPoint","setModule","internal","address","currentTypeId","currentType","reset","stateId","resetState","iterator","next","done","getText","result","textCallback","_Tree","copy","unmarshalNode","rootNodeWithOffset","offsetBytes","offsetExtent","TRANSFER_BUFFER","marshalPoint","edit","marshalEdit","getChangedRanges","other","unmarshalRange","getIncludedRanges","_TreeCursor","unmarshalTreeCursor","marshalTreeCursor","currentFieldId","currentFieldName","fields","currentDescendantIndex","nodeType","nodeTypeId","nodeStateId","nodeId","nodeIsNamed","nodeIsMissing","nodeText","unmarshalPoint","gotoFirstChild","gotoLastChild","gotoParent","gotoNextSibling","gotoPreviousSibling","gotoDescendant","goalDescendantIndex","gotoFirstChildForIndex","goalIndex","gotoFirstChildForPosition","goalPosition","marshalNode","resetTo","cursor","_children","_namedChildren","typeId","grammarId","grammarType","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","subbedPointRow","subbedPointColumn","toString","unmarshalCaptures","query","patternIndex","captureIndex","captureNames","marshalRange","unmarshalLanguageMetadata","major_version","minor_version","patch_version","LANGUAGE_FUNCTION_REGEX","_Language","abiVersion","fieldCount","stateCount","fieldIdForName","fieldNameForId","idForNodeType","named","typeLength","typeAddress","nodeTypeCount","nodeTypeForId","nodeTypeIsNamed","nodeTypeIsVisible","supertypes","subtypes","supertype","nextState","lookaheadIterator","input","globalThis","fs2","t","readFile","body2","retryResp","clone","compileStreaming","symbolNames","keys","functionName","test","languageAddress","import_web_tree_sitter","Module2","initializeBinding","moduleOptions","checkModule","logCallback","initialize","version","oldTree","progressCallback","rangeCount","rangeAddress","includedRanges","treeAddress","setLogger","getLogger","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","suffix","parseAnyPredicate","steps","textPredicates","isPositive","matchAll","captureName1","captureName2","captures","nodes1","nodes2","compare","n1","n2","positive","captureName","stringValue","matches","doesNotMatch","nodes","parseMatchPredicate","regex","RegExp","parseAnyOfPredicate","stringSteps","s","parseIsPredicate","assertedProperties","refutedProperties","properties","parseSetDirective","setProperties","parsePattern","stepType","stepValueId","stringValues","predicates","exceededMatchLimit","captureQuantifiers","matchLimit","source","sourceLength","sourceAddress","errorId","errorByte","errorIndex","stringCount","captureCount","patternCount","nameAddress","nameLength","captureQuantifiersArray","quantifier","valueAddress","predicatesAddress","stepCount","stepAddress","freeze","startContainingPosition","endContainingPosition","startContainingIndex","endContainingIndex","maxStartDepth","rawCount","startAddress","didExceedMatchLimit","filteredCount","capture","predicatesForPattern","disableCapture","captureNameLength","captureNameAddress","disablePattern","startIndexForPattern","endIndexForPattern","captureIndexForName","isPatternRooted","isPatternNonLocal","isPatternGuaranteedAtStep","byteIndex","__webpack_module_cache__","moduleId","cachedModule","__webpack_modules__","getProto","leafPrototypes","mode","ns","r","def","definition","binding","o","toStringTag","__webpack_exports__"],"sourceRoot":""}
+{"version":3,"file":"cli.js","mappings":"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","sources":["webpack://energy-state-analyzer/./src/cli.ts","webpack://energy-state-analyzer/./src/cliModes.ts","webpack://energy-state-analyzer/./src/core/analyze.ts","webpack://energy-state-analyzer/./src/core/detectors/cognitive.ts","webpack://energy-state-analyzer/./src/core/detectors/coherence.ts","webpack://energy-state-analyzer/./src/core/detectors/cyclomatic.ts","webpack://energy-state-analyzer/./src/core/detectors/inversion.ts","webpack://energy-state-analyzer/./src/core/detectors/logicalControlFlow.ts","webpack://energy-state-analyzer/./src/core/detectors/magicNumber.ts","webpack://energy-state-analyzer/./src/core/detectors/magicString.ts","webpack://energy-state-analyzer/./src/core/detectors/matchOpportunity.ts","webpack://energy-state-analyzer/./src/core/detectors/nesting.ts","webpack://energy-state-analyzer/./src/core/detectors/opaqueBoolean.ts","webpack://energy-state-analyzer/./src/core/detectors/parameterCount.ts","webpack://energy-state-analyzer/./src/core/detectors/primitiveObsession.ts","webpack://energy-state-analyzer/./src/core/esaignore.ts","webpack://energy-state-analyzer/./src/core/position.ts","webpack://energy-state-analyzer/./src/core/report.ts","webpack://energy-state-analyzer/./src/core/reportDiff.ts","webpack://energy-state-analyzer/./src/core/reportHuman.ts","webpack://energy-state-analyzer/./src/core/scan.ts","webpack://energy-state-analyzer/./src/core/severityCounts.ts","webpack://energy-state-analyzer/./src/core/suppressions.ts","webpack://energy-state-analyzer/./src/languages/fsharp.ts","webpack://energy-state-analyzer/./src/languages/index.ts","webpack://energy-state-analyzer/./src/languages/kotlin.ts","webpack://energy-state-analyzer/./src/languages/python.ts","webpack://energy-state-analyzer/./src/languages/typescript.ts","webpack://energy-state-analyzer/./src/types.ts","webpack://energy-state-analyzer/external node-commonjs \"child_process\"","webpack://energy-state-analyzer/external node-commonjs \"fs\"","webpack://energy-state-analyzer/external node-commonjs \"fs/promises\"","webpack://energy-state-analyzer/external node-commonjs \"path\"","webpack://energy-state-analyzer/./node_modules/web-tree-sitter/web-tree-sitter.cjs","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":["#!/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 or a CI job) can\n// gate on 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\n// invariant: `energy-state-cli <single-file>` with no other flags keeps printing the flat\n// EnergyViolation[] JSON array it always has — this is the published npm CLI contract\n// (README's \"Command-Line Usage\"), and scan/diff mode are additive, not a replacement for it\nimport * as fs from 'fs';\n\nimport { AnalyzeThresholds } from './core/analyze';\nimport { DEFAULT_NESTING_THRESHOLDS } from './core/detectors/nesting';\nimport { DEFAULT_CYCLOMATIC_THRESHOLDS } from './core/detectors/cyclomatic';\nimport { DEFAULT_COGNITIVE_THRESHOLDS } from './core/detectors/cognitive';\nimport { printUsage, runDiff, runLegacySingleFile, runScan, ReportFormat } from './cliModes';\n\n// decision: every flag recognized here (including --base-ref/--report) takes exactly one\n// value, so a positional path list can be recovered by skipping each `--flag value` pair\n// rather than needing a real argument-parsing library\nconst VALUE_FLAGS = [\n    'base-ref',\n    'report',\n    'medium-nesting',\n    'high-nesting',\n    'medium-cyclomatic',\n    'high-cyclomatic',\n    'medium-cognitive',\n    'high-cognitive'\n];\n\nfunction parseArgs(argv: string[]) {\n    const paths: string[] = [];\n    const flagValues = new Map<string, string>();\n\n    for (let i = 0; i < argv.length; i++) {\n        const arg = argv[i];\n        if (arg.startsWith('--')) {\n            const name = arg.slice(2);\n            if (VALUE_FLAGS.includes(name)) {\n                flagValues.set(name, argv[i + 1]);\n                i++;\n            }\n        } else {\n            paths.push(arg);\n        }\n    }\n\n    const flag = (name: string): string | undefined => flagValues.get(name);\n    const numberFlag = (name: string): number | undefined => {\n        const value = flag(name);\n        return value !== undefined ? Number(value) : undefined;\n    };\n\n    return {\n        paths,\n        baseRef: flag('base-ref'),\n        report: flag('report') as ReportFormat | undefined,\n        nesting: {\n            mediumThreshold: numberFlag('medium-nesting'),\n            highThreshold: numberFlag('high-nesting')\n        },\n        cyclomatic: {\n            mediumThreshold: numberFlag('medium-cyclomatic'),\n            highThreshold: numberFlag('high-cyclomatic')\n        },\n        cognitive: {\n            mediumThreshold: numberFlag('medium-cognitive'),\n            highThreshold: numberFlag('high-cognitive')\n        }\n    };\n}\n\ntype ThresholdOverride = { mediumThreshold?: number; highThreshold?: number };\n\n// decision: returns undefined (not the detector's own default) when neither flag was passed —\n// analyzeSource already falls back to each detector's own DEFAULT_*_THRESHOLDS when its entry is\n// undefined, so resolving the default here too would just be a second place that default could\n// drift out of sync with the detector module that owns it\nfunction resolveThresholdOverride<T extends ThresholdOverride>(\n    override: ThresholdOverride,\n    defaults: T\n): T | undefined {\n    if (override.mediumThreshold === undefined && override.highThreshold === undefined) {\n        return undefined;\n    }\n    return {\n        ...defaults,\n        mediumThreshold: override.mediumThreshold ?? defaults.mediumThreshold,\n        highThreshold: override.highThreshold ?? defaults.highThreshold\n    };\n}\n\nfunction buildThresholds(parsed: ReturnType<typeof parseArgs>): AnalyzeThresholds {\n    return {\n        nesting: resolveThresholdOverride(parsed.nesting, DEFAULT_NESTING_THRESHOLDS),\n        cyclomatic: resolveThresholdOverride(parsed.cyclomatic, DEFAULT_CYCLOMATIC_THRESHOLDS),\n        cognitive: resolveThresholdOverride(parsed.cognitive, DEFAULT_COGNITIVE_THRESHOLDS)\n    };\n}\n\nasync function main(): Promise<void> {\n    const parsed = parseArgs(process.argv.slice(2));\n    const thresholds = buildThresholds(parsed);\n    const reportFormat: ReportFormat = parsed.report ?? (parsed.baseRef || parsed.paths.length !== 1 ? 'md' : 'json');\n\n    if (parsed.baseRef) {\n        await runDiff(parsed.baseRef, parsed.paths, thresholds, reportFormat);\n        return;\n    }\n\n    if (parsed.paths.length === 0) {\n        printUsage();\n        process.exit(2);\n    }\n\n    if (\n        parsed.paths.length === 1 &&\n        fs.existsSync(parsed.paths[0]) &&\n        fs.statSync(parsed.paths[0]).isFile() &&\n        !parsed.report\n    ) {\n        await runLegacySingleFile(parsed.paths[0], thresholds);\n        return;\n    }\n\n    await runScan(parsed.paths, thresholds, reportFormat);\n}\n\nmain().catch((error) => {\n    console.error('energy-state-cli failed:', error);\n    process.exit(1);\n});\n","// Execution engine for each CLI invocation shape (single file, scan, diff) — split out of\n// cli.ts so argument parsing and mode execution are two separate, independently-readable\n// concerns (the coherence detector flagged cli.ts itself for mixing both in one file).\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { execFileSync } from 'child_process';\nconst { Parser, Language } = require('web-tree-sitter');\n\nimport { analyzeSource, AnalyzeThresholds } from './core/analyze';\nimport { LanguageAdapter } from './core/language';\nimport { resolveLanguageForFile } from './languages';\nimport { resolveSupportedFiles } from './core/scan';\nimport { isIgnored, loadIgnorePatterns } from './core/esaignore';\nimport {\n    FileResult,\n    FileSummary,\n    hasBlockingViolations,\n    renderDiffMarkdown,\n    renderHumanReport,\n    renderMarkdownReport,\n    summarize,\n    summarizeFile,\n    diffSummaries\n} from './core/report';\nimport { EnergyViolation, SEVERITY } from './types';\n\nexport type ReportFormat = 'json' | 'md' | 'human';\n\nexport function printUsage(): void {\n    console.error('Usage: energy-state-cli <file.py|.fs|.fsx|.ts> [thresholds...]');\n    console.error(\n        '       energy-state-cli <path...> [--report json|md|human] [thresholds...]              (scan a directory/subtree)'\n    );\n    console.error(\n        '       energy-state-cli --base-ref <ref> [<path...>] [--report json|md] [thresholds...]  (diff PR head against a base ref)'\n    );\n    console.error(\n        'Thresholds: --medium-nesting N --high-nesting N --medium-cyclomatic N --high-cyclomatic N --medium-cognitive N --high-cognitive N'\n    );\n}\n\n// decision: caches one parser instance per language adapter — scan/diff mode analyze many\n// files, and re-running Parser.init()/Language.load() per file would be wasteful I/O\nconst parserCache = new Map<LanguageAdapter, any>();\n\nasync function loadParser(adapter: LanguageAdapter) {\n    const cached = parserCache.get(adapter);\n    if (cached) {\n        return cached;\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    parserCache.set(adapter, parser);\n    return parser;\n}\n\nasync function analyzeFile(\n    filePath: string,\n    sourceCode: string,\n    thresholds: AnalyzeThresholds\n): Promise<EnergyViolation[]> {\n    const adapter = resolveLanguageForFile(filePath);\n    if (!adapter) {\n        return [];\n    }\n    const parser = await loadParser(adapter);\n    const tree = parser.parse(sourceCode);\n    return analyzeSource(sourceCode, tree, adapter, filePath, thresholds);\n}\n\nfunction exitForCounts(counts: { low: number; medium: number; high: number }): never {\n    process.exit(hasBlockingViolations(counts) ? 1 : 0);\n}\n\nexport async function runLegacySingleFile(filePath: string, thresholds: AnalyzeThresholds): Promise<void> {\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    const violations = await analyzeFile(filePath, sourceCode, thresholds);\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\nexport async function runScan(\n    paths: string[],\n    thresholds: AnalyzeThresholds,\n    reportFormat: ReportFormat\n): Promise<void> {\n    const files = resolveSupportedFiles(paths);\n    const results: FileResult[] = [];\n\n    for (const filePath of files) {\n        const sourceCode = fs.readFileSync(filePath, 'utf8');\n        const violations = await analyzeFile(filePath, sourceCode, thresholds);\n        // decision: reports the path relative to cwd — resolveSupportedFiles resolves\n        // absolute paths internally for reliable dedup, but a repo-wide report reads far\n        // better as \"src/foo.ts\" than a full filesystem path repeated on every row\n        results.push({ filePath: path.relative(process.cwd(), filePath), violations });\n    }\n\n    const summary = summarize(results);\n    if (reportFormat === 'human') {\n        console.log(renderHumanReport(results));\n    } else if (reportFormat === 'md') {\n        console.log(renderMarkdownReport(summary));\n    } else {\n        console.log(JSON.stringify(summary, null, 2));\n    }\n    exitForCounts(summary.totalCounts);\n}\n\nfunction changedFilesFromGit(baseRef: string): string[] {\n    const output = execFileSync('git', ['diff', '--name-only', '--diff-filter=d', `${baseRef}...HEAD`], {\n        encoding: 'utf8'\n    });\n    return output\n        .split('\\n')\n        .map((line) => line.trim())\n        .filter(Boolean);\n}\n\n// decision: returns null (not throwing) when the file doesn't exist at baseRef — a newly\n// added file has no base content, which is a normal \"new file\" case, not an error\nfunction readAtRef(ref: string, filePath: string): string | null {\n    try {\n        // decision: pipes stderr instead of inheriting it — git's own \"fatal: path ... exists\n        // on disk, but not in <ref>\" would otherwise print to the CLI's stderr on every new\n        // file, duplicating (and outnumbering) our own, already-informative message below\n        return execFileSync('git', ['show', `${ref}:${filePath}`], {\n            encoding: 'utf8',\n            stdio: ['ignore', 'pipe', 'ignore']\n        });\n    } catch (error) {\n        console.error(`energy-state-cli: could not read ${filePath} at ${ref} (new file or rename) — treating as new`);\n        return null;\n    }\n}\n\nexport async function runDiff(\n    baseRef: string,\n    explicitPaths: string[],\n    thresholds: AnalyzeThresholds,\n    reportFormat: ReportFormat\n): Promise<void> {\n    const rootDir = process.cwd();\n    const ignorePatterns = loadIgnorePatterns(rootDir);\n    const changedFiles = (explicitPaths.length > 0 ? explicitPaths : changedFilesFromGit(baseRef))\n        .filter((filePath) => resolveLanguageForFile(filePath) && fs.existsSync(filePath))\n        .filter((filePath) => !isIgnored(path.resolve(filePath), rootDir, ignorePatterns));\n\n    const headSummaries: FileSummary[] = [];\n    const baseSummaries: FileSummary[] = [];\n\n    for (const filePath of changedFiles) {\n        const headSource = fs.readFileSync(filePath, 'utf8');\n        const headViolations = await analyzeFile(filePath, headSource, thresholds);\n        headSummaries.push(summarizeFile({ filePath, violations: headViolations }));\n\n        const baseSource = readAtRef(baseRef, filePath);\n        if (baseSource !== null) {\n            const baseViolations = await analyzeFile(filePath, baseSource, thresholds);\n            baseSummaries.push(summarizeFile({ filePath, violations: baseViolations }));\n        }\n    }\n\n    const entries = diffSummaries(baseSummaries, headSummaries);\n    console.log(reportFormat === 'md' ? renderDiffMarkdown(entries, baseRef) : JSON.stringify(entries, null, 2));\n\n    // decision: diff-mode's exit code reflects whether anything in the diff *worsened*, not\n    // \"does head have any medium/high violation\" (scan/legacy mode's rule) — a PR touching a\n    // file that already carried debt, or a genuinely new file, should not fail this check on\n    // pre-existing severity alone; only a file this PR made worse should block it\n    process.exit(entries.some((entry) => entry.status === 'worsened') ? 1 : 0);\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 { analyzeMagicNumbers, MagicNumberOptions, DEFAULT_MAGIC_NUMBER_OPTIONS } from './detectors/magicNumber';\nimport { analyzeMagicStrings, MagicStringOptions, DEFAULT_MAGIC_STRING_OPTIONS } from './detectors/magicString';\nimport { analyzeParameterCount } from './detectors/parameterCount';\nimport { analyzeInversionOpportunities } from './detectors/inversion';\nimport { analyzePrimitiveObsession } from './detectors/primitiveObsession';\nimport {\n    analyzeMatchOpportunities,\n    MatchOpportunityThresholds,\n    DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS\n} from './detectors/matchOpportunity';\nimport { analyzeLogicalControlFlow } from './detectors/logicalControlFlow';\nimport { analyzeOpaqueBooleanLiteral } from './detectors/opaqueBoolean';\nimport { applySuppressions } from './suppressions';\n\nexport interface AnalyzeThresholds {\n    nesting?: NestingThresholds;\n    cyclomatic?: CyclomaticThresholds;\n    cognitive?: CognitiveThresholds;\n    coherence?: CoherenceThresholds;\n    matchOpportunity?: MatchOpportunityThresholds;\n    magicNumber?: MagicNumberOptions;\n    magicString?: MagicStringOptions;\n}\n\n// esa-ignore-file: coherence\n// decision: this file's import count is inherent to being the one place that wires up every\n// detector (one import per detector, by design) — not accidental grab-bag sprawl, so the\n// import-sprawl coherence check is suppressed file-wide rather than chased by deleting imports.\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 magicNumber/magicString) — 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(\n        ...analyzeFunctionComplexity(tree, positions, language, thresholds.cyclomatic ?? DEFAULT_CYCLOMATIC_THRESHOLDS)\n    );\n    violations.push(\n        ...analyzeCognitiveComplexity(tree, positions, language, thresholds.cognitive ?? DEFAULT_COGNITIVE_THRESHOLDS)\n    );\n    violations.push(\n        ...analyzeFileCoherence(tree, fileName, language, thresholds.coherence ?? DEFAULT_COHERENCE_THRESHOLDS)\n    );\n    violations.push(\n        ...analyzeMagicNumbers(tree, positions, language, thresholds.magicNumber ?? DEFAULT_MAGIC_NUMBER_OPTIONS)\n    );\n    violations.push(\n        ...analyzeMagicStrings(tree, positions, language, thresholds.magicString ?? DEFAULT_MAGIC_STRING_OPTIONS)\n    );\n    violations.push(...analyzeParameterCount(tree, positions, language));\n    violations.push(...analyzeInversionOpportunities(tree, positions, language));\n    violations.push(...analyzePrimitiveObsession(tree, positions, language));\n    violations.push(\n        ...analyzeMatchOpportunities(\n            tree,\n            positions,\n            language,\n            thresholds.matchOpportunity ?? DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS\n        )\n    );\n    violations.push(...analyzeLogicalControlFlow(tree, positions, language));\n    violations.push(...analyzeOpaqueBooleanLiteral(tree, positions, language));\n\n    // decision: suppression is applied last, over the full combined list — an esa-ignore\n    // directive can name any violation type regardless of which detector produced it, so it\n    // must see everything before deciding what's unused.\n    const { violations: suppressed, suppressionNotes } = applySuppressions(violations, sourceText);\n    return [...suppressed, ...suppressionNotes];\n}\n","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) {\n            // 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(\n    functionNode: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): 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","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    // Share (0-1) of a file's functions that must share a leading name word (e.g. all\n    // `extractX`/`extractY`) for the file to be treated as one coherent domain broken into many\n    // small steps, rather than a grab-bag of unrelated helpers, and skip the raw function-count\n    // sprawl check below.\n    singleDomainNameShare: number;\n}\n\nexport const DEFAULT_COHERENCE_THRESHOLDS: CoherenceThresholds = {\n    largeFunctionLines: 20,\n    maxLargeFunctions: 5,\n    singleDomainNameShare: 0.7\n};\n\nfunction lineCount(node: any): number {\n    return node.endPosition.row - node.startPosition.row + 1;\n}\n\n// decision: a raw function name is a weak signal on its own, but a *dominant leading word*\n// shared across most of a file's functions (extractFoo/extractBar/extractBaz) is a cheap,\n// AST-only proxy for \"this file is one coherent domain factored into many small steps\" —\n// exactly the case the function-count sprawl check below would otherwise misflag, since it\n// can't tell that apart from an actual grab-bag of unrelated helpers by count alone\nfunction leadingNameWord(node: any): string | null {\n    const nameNode = node.children?.find((c: any) => c.type === 'identifier');\n    if (!nameNode?.text) {\n        return null;\n    }\n    const match = /^[a-z]+/.exec(nameNode.text);\n    return match ? match[0] : nameNode.text.toLowerCase();\n}\n\nfunction looksLikeSingleDomain(functions: any[], minShare: number): boolean {\n    const leadingWords = functions.map(leadingNameWord).filter((word): word is string => word !== null);\n    if (leadingWords.length === 0) {\n        return false;\n    }\n\n    const wordCounts = new Map<string, number>();\n    for (const word of leadingWords) {\n        wordCounts.set(word, (wordCounts.get(word) ?? 0) + 1);\n    }\n\n    const dominantWordCount = Math.max(...wordCounts.values());\n    return dominantWordCount / leadingWords.length >= minShare;\n}\n\nfunction collectFunctionsAndImports(tree: any, language: LanguageAdapter): { functions: any[]; imports: string[] } {\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 (\n            node.isNamed &&\n            (node.type === nodeTypes.importStatement || node.type === nodeTypes.importFromStatement)\n        ) {\n            // decision: requires isNamed, not just a type match — Kotlin's import rule is\n            // literally named `import`, which collides with the anonymous `import` keyword\n            // token that is itself a child of every import node (node.type for an anonymous\n            // node is its literal text). Without this guard, every Kotlin import is counted\n            // twice: once for the named node, once for its own leading keyword token.\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    return { functions, imports };\n}\n\n// decision: the raw function-count trigger (8/12) and its severity escalation (15) are\n// deliberately not part of CoherenceThresholds like largeFunctionLines/maxLargeFunctions are —\n// they're secondary heuristics tuned around the utils-file naming proxy, not a threshold users\n// are expected to retune independently\nconst UTILS_FILE_FUNCTION_THRESHOLD = 8;\nconst GENERIC_FUNCTION_COUNT_THRESHOLD = 12;\nconst HIGH_FUNCTION_COUNT_THRESHOLD = 15;\nconst LARGE_FUNCTION_SEVERITY_MULTIPLIER = 1.5;\nconst IMPORT_COUNT_THRESHOLD = 10;\nconst HIGH_IMPORT_COUNT_THRESHOLD = 15;\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\"\nfunction checkFunctionCountSprawl(\n    functions: any[],\n    fileName: string,\n    thresholds: CoherenceThresholds\n): EnergyViolation | null {\n    if (functions.length <= UTILS_FILE_FUNCTION_THRESHOLD) {\n        return null;\n    }\n\n    const baseName = fileName.split('/').pop() || '';\n    const isUtilsFile = baseName.includes('util') || baseName.includes('helper') || baseName.includes('common');\n    // decision: an explicit utils/helper/common filename overrides the naming-cohesion signal — a module that already admits to being a grab-bag in its own name doesn't get to argue its way out via consistent prefixes\n    const singleDomain = !isUtilsFile && looksLikeSingleDomain(functions, thresholds.singleDomainNameShare);\n\n    if (!isUtilsFile && (functions.length <= GENERIC_FUNCTION_COUNT_THRESHOLD || singleDomain)) {\n        return null;\n    }\n\n    return {\n        line: 0,\n        column: 0,\n        type: VIOLATION_TYPE.COHERENCE,\n        severity: functions.length > HIGH_FUNCTION_COUNT_THRESHOLD ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n        message: `File coherence warning: ${functions.length} functions in one file. Consider splitting by domain.`\n    };\n}\n\n// Flag files with too many large functions, regardless of total function count - a module with\n// 30 small functions is fine, one with 6 sprawling ones isn't.\nfunction checkLargeFunctionSprawl(functions: any[], thresholds: CoherenceThresholds): EnergyViolation | null {\n    const largeFunctions = functions.filter((fn) => lineCount(fn) > thresholds.largeFunctionLines);\n    if (largeFunctions.length <= thresholds.maxLargeFunctions) {\n        return null;\n    }\n\n    return {\n        line: 0,\n        column: 0,\n        type: VIOLATION_TYPE.COHERENCE,\n        severity:\n            largeFunctions.length > thresholds.maxLargeFunctions * LARGE_FUNCTION_SEVERITY_MULTIPLIER\n                ? SEVERITY.HIGH\n                : 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)\nfunction checkImportSprawl(imports: string[]): EnergyViolation | null {\n    if (imports.length <= IMPORT_COUNT_THRESHOLD) {\n        return null;\n    }\n\n    return {\n        line: 0,\n        column: 0,\n        type: VIOLATION_TYPE.COHERENCE,\n        severity: imports.length > HIGH_IMPORT_COUNT_THRESHOLD ? SEVERITY.HIGH : SEVERITY.MEDIUM,\n        message: `Import sprawl: ${imports.length} imports suggest this file does too much.`\n    };\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 { functions, imports } = collectFunctionsAndImports(tree, language);\n\n    return [\n        checkFunctionCountSprawl(functions, fileName, thresholds),\n        checkLargeFunctionSprawl(functions, thresholds),\n        checkImportSprawl(imports)\n    ].filter((violation): violation is EnergyViolation => violation !== null);\n}\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 (\n            language.decisionNodeTypes.includes(node.type) ||\n            language.getBooleanOperator(node) !== null ||\n            language.isTryElseClause(node)\n        ) {\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(\n    functionNode: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): ComplexityHotspot[] {\n    const hotspots: ComplexityHotspot[] = [];\n\n    function walk(node: any, depth: number, isRoot: boolean) {\n        let nextDepth = depth;\n        if (\n            language.decisionNodeTypes.includes(node.type) ||\n            language.getBooleanOperator(node) !== null ||\n            language.isTryElseClause(node)\n        ) {\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';\n\n// The \"Inversion Opportunity\" detector - finds patterns that could benefit from early returns\nexport function analyzeInversionOpportunities(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): 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        //\n        // decision: also checks one level of grandchildren, not just direct children — Kotlin's\n        // function_declaration wraps its block in an intermediate function_body node\n        // (function_declaration -> function_body -> block), unlike Python/TS/F# where the block\n        // (or its equivalent) sits directly under the function node\n        const body =\n            functionNode.children.find((child: any) => child.type === nodeTypes.block) ??\n            functionNode.children\n                .flatMap((child: any) => child.children ?? [])\n                .find((child: any) => child.type === nodeTypes.block);\n        if (!body) {\n            return;\n        }\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(\n            (child: any) => 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            // decision: matches against language.nestingControlTypes rather than the\n            // nodeTypes.ifStatement/forStatement/whileStatement trio directly — TypeScript's\n            // `for...of`/`for...in` parses as its own for_in_statement node, distinct from\n            // nodeTypes.forStatement's plain `for_statement`, and nestingControlTypes is the\n            // per-language set that already accounts for that (bug found by running this\n            // detector on its own source: a sibling for-of loop went unseen by the old filter,\n            // making its lone if-sibling look like the only statement in this body and get\n            // mistaken for a validation-chain step)\n            const statements =\n                currentNode.children?.filter((child: any) => language.nestingControlTypes.includes(child.type)) || [];\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                //\n                // decision: grammars with no elseClause wrapper (Kotlin, F#) can't be checked via\n                // a single child's type — Kotlin's else-branch is either a second nodeTypes.block\n                // child or a directly-nested ifStatement child, with no wrapper node distinguishing\n                // it from the then-branch's own block. F#'s block-less grammar still can't detect a\n                // plain (non-if) else this way — pre-existing, not a regression from this fallback.\n                const hasElse = nodeTypes.elseClause\n                    ? ifStatement.children.some((child: any) => child.type === nodeTypes.elseClause)\n                    : ifStatement.children.filter((child: any) => child.type === nodeTypes.block).length > 1 ||\n                      ifStatement.children.some((child: any) => child.type === nodeTypes.ifStatement);\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            // invariant: never descends into a nested function/method's body — that function is\n            // walked as its own separate analyzeFunction call once traverse() reaches it, so\n            // counting its if-nesting here too would both double-report the same location and\n            // misattribute nesting depth to the wrong enclosing function (mirrors the same rule\n            // in cognitive.ts's walk())\n            if (language.isFunctionDefinition(node)) {\n                return;\n            }\n\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 { 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(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): 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:\n                    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 { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\nexport interface MagicNumberOptions {\n    enabled: boolean;\n    // Numeric literals that never carry hidden meaning worth naming (loop\n    // bounds, unit steps) — checked against the literal's signed value.\n    allowlist: number[];\n}\n\nexport const DEFAULT_MAGIC_NUMBER_OPTIONS: MagicNumberOptions = {\n    enabled: true,\n    allowlist: [0, 1, -1, 2]\n};\n\n// The \"Magic Number\" detector: numbers don't get an interpolation-style escape hatch the way\n// strings do, so this stays broad (any significant literal outside a named binding) and leans\n// on the allowlist plus a few structural exemptions (index position, default parameter value)\n// to keep it from flagging the common idioms where a bare number isn't actually magic.\nexport function analyzeMagicNumbers(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter,\n    options: MagicNumberOptions = DEFAULT_MAGIC_NUMBER_OPTIONS\n): EnergyViolation[] {\n    const violations: EnergyViolation[] = [];\n    if (!options.enabled) {\n        return violations;\n    }\n    const { nodeTypes } = language;\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                // decision: checked before the module-scope walk below, and independent of it —\n                // an explicit compile-time-constant marker (Kotlin's `const val`) is valid at any\n                // nesting depth (companion object, object declaration, etc.), unlike the\n                // module-scope heuristic that walk relies on for languages with no such marker\n                if (language.isExplicitConstant(parent)) {\n                    return true;\n                }\n                // decision: Python wraps every top-level `name = value` in an\n                // `expression_statement` between the assignment and the module root (unlike\n                // TS's `lexical_declaration`, which sits directly under `program`) — unwrap it\n                // before checking against module/export so `MAX_RETRIES = 5` at module scope\n                // is still recognized as a constant binding.\n                let grandparent = parent.parent;\n                if (grandparent?.type === nodeTypes.expressionStatement) {\n                    grandparent = grandparent.parent;\n                }\n                if (grandparent?.type === nodeTypes.module) {\n                    // decision: F#'s `declaration_expression` node type is reused both for the\n                    // true module root and for wrapping a nested `let` binding's continuation\n                    // inside a function body (there's no separate node type for \"this let is\n                    // the function's actual last expression\" vs \"this let is module-level\") — so\n                    // matching nodeTypes.module here isn't enough on its own; this also has to\n                    // rule out an enclosing function definition somewhere further up\n                    return !hasEnclosingFunction(parent);\n                }\n                if (\n                    nodeTypes.exportStatement &&\n                    grandparent?.type === nodeTypes.exportStatement &&\n                    grandparent.parent?.type === nodeTypes.module\n                ) {\n                    return true;\n                }\n            }\n            parent = parent.parent;\n        }\n        return false;\n    }\n\n    function hasEnclosingFunction(assignmentNode: any): boolean {\n        let ancestor = assignmentNode.parent;\n        while (ancestor) {\n            if (language.isFunctionDefinition(ancestor)) {\n                return true;\n            }\n            ancestor = ancestor.parent;\n        }\n        return false;\n    }\n\n    function isIndexPosition(node: any): boolean {\n        return !!node.parent && language.subscriptNodeTypes.includes(node.parent.type);\n    }\n\n    // decision: a plain `-` unary parent isn't its own node type across every grammar, so this\n    // checks the structural shape (a 2-child parent whose first child is a literal `-` token)\n    // instead of adding another per-language adapter hook for something this mechanical\n    function signedValue(node: any, rawValue: number): number {\n        const parent = node.parent;\n        const isNegated = parent?.children?.length === 2 && parent.children[0]?.text === '-';\n        return isNegated ? -rawValue : rawValue;\n    }\n\n    function traverse(node: any) {\n        if (node.type === nodeTypes.integerLiteral || node.type === nodeTypes.floatLiteral) {\n            // decision: always parseFloat, even for integerLiteral nodes — TS has no separate\n            // floatLiteral node type (both map to nodeTypes.integerLiteral), so parseInt would\n            // silently truncate a literal like `1.08` down to `1` and match the allowlist\n            const rawValue = parseFloat(node.text);\n            // decision: skips non-numeric text outright rather than falling through to the\n            // allowlist/exemption checks — F#'s float grammar nests a `float`-typed fragment\n            // node (digits/'.'/digits) inside its own `float`-typed literal, and TS's\n            // `predefined_type` keyword token for the `number` annotation shares nodeTypes'\n            // 'number' node type with the actual numeric-literal node; neither is a real value\n            if (!Number.isNaN(rawValue)) {\n                const value = signedValue(node, rawValue);\n\n                const isExempt =\n                    options.allowlist.includes(value) ||\n                    isInConstantContext(node) ||\n                    isIndexPosition(node) ||\n                    language.isDefaultParameterValue(node);\n\n                if (!isExempt) {\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            // A literal's own children (if any) are fragments of the same value, not\n            // separate literals — never descend into them.\n            return;\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\nexport interface MagicStringOptions {\n    enabled: boolean;\n    // Only flag a string once it recurs at a decision point at least this many times across\n    // the file — mirrors Sonar's S1192, and cuts single-use false positives further.\n    minDuplicates: number;\n    // Literal contents that are never worth naming regardless of how often they recur.\n    allowlist: string[];\n}\n\nexport const DEFAULT_MAGIC_STRING_OPTIONS: MagicStringOptions = {\n    enabled: true,\n    minDuplicates: 2,\n    allowlist: ['', 'utf-8', '__main__']\n};\n\n// The \"Magic String\" detector: unlike numbers, strings get a narrow scope — only literals\n// standing at a decision point (compared, checked for membership, or used as a dict/object\n// key) are candidates, since that's where an unnamed string actually risks a silent typo. Any\n// other string (a message, a docstring, an interpolated template) is left alone entirely.\nexport function analyzeMagicStrings(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter,\n    options: MagicStringOptions = DEFAULT_MAGIC_STRING_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        return node.parent?.type === nodeTypes.expressionStatement;\n    }\n\n    function stripQuotes(text: string): string {\n        return text.length >= 2 ? text.slice(1, -1) : text;\n    }\n\n    function isEqualityComparisonOperand(node: any): boolean {\n        // decision: also checks the grandparent, not just the parent — F#'s grammar wraps a\n        // literal operand in an intermediate `const` node before it reaches the\n        // `infix_expression`, so the comparison node itself sits one level further up than in\n        // Python/TS. Checking the parent alone would silently drop every F# string comparison.\n        const candidates = [node.parent, node.parent?.parent].filter(Boolean);\n        // decision: compares node identity by `.id`, not `===` — web-tree-sitter mints a fresh\n        // JS wrapper object on every `.children`/`.parent` access, so two accessors that reach\n        // the same underlying tree node are not reference-equal even though `.id` matches\n        return candidates.some((candidate) =>\n            language\n                .getEqualityComparisons(candidate)\n                .some(({ left, right }) => left.id === node.id || right.id === node.id)\n        );\n    }\n\n    function isMembershipOperand(node: any, content: string): boolean {\n        const container = node.parent?.parent;\n        if (!container) {\n            return false;\n        }\n        return language.getMembershipComparisons(container).some(({ values }) => values.includes(content));\n    }\n\n    function isKeyOrIndexPosition(node: any): boolean {\n        return !!node.parent && language.subscriptNodeTypes.includes(node.parent.type);\n    }\n\n    function isDecisionPoint(node: any, content: string): boolean {\n        return isEqualityComparisonOperand(node) || isMembershipOperand(node, content) || isKeyOrIndexPosition(node);\n    }\n\n    function isExempt(node: any, content: string): boolean {\n        return (\n            isDocstring(node) ||\n            language.isFormattedOrInterpolatedString(node) ||\n            options.allowlist.includes(content) ||\n            content.length <= 1\n        );\n    }\n\n    interface Candidate {\n        node: any;\n        content: string;\n    }\n    const candidates: Candidate[] = [];\n\n    function traverse(node: any) {\n        if (node.type === nodeTypes.stringLiteral) {\n            const content = stripQuotes(node.text);\n            if (isDecisionPoint(node, content) && !isExempt(node, content)) {\n                candidates.push({ node, content });\n            }\n        }\n\n        for (const child of node.children) {\n            traverse(child);\n        }\n    }\n\n    traverse(tree.rootNode);\n\n    const byContent = new Map<string, Candidate[]>();\n    for (const candidate of candidates) {\n        const group = byContent.get(candidate.content) ?? [];\n        group.push(candidate);\n        byContent.set(candidate.content, group);\n    }\n\n    for (const [content, group] of byContent) {\n        if (group.length < options.minDuplicates) {\n            continue;\n        }\n        const first = group[0].node;\n        const position = positions.toPosition(first.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: \"${content}\" is compared/keyed against directly ${group.length} time(s). Consider extracting to a named constant or enum.`\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 one of three grammar\n// shapes for its continuations —\n//   - flat elif siblings (Python/F#, via getElseIfBranches)\n//   - else if there are none, `else if`-nested if-statements one level\n//     inside an else_clause wrapper (TypeScript's shape)\n//   - or, for grammars with no else_clause wrapper at all (Kotlin's\n//     if_expression), a nested if-statement sitting as a *direct* child of\n//     the previous one, with no wrapper node to key off\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 nestedIf = language.nodeTypes.elseClause\n            ? current.children\n                  ?.find((c: any) => c.type === language.nodeTypes.elseClause)\n                  ?.children?.find((c: any) => c.type === language.nodeTypes.ifStatement)\n            : current.children?.find((c: any) => c.type === language.nodeTypes.ifStatement);\n        if (!nestedIf) {\n            break;\n        }\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(\n    branchNode: any,\n    otherBranches: Set<any>,\n    language: LanguageAdapter\n): 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 (\n            node.type === nodeTypes.stringLiteral ||\n            node.type === nodeTypes.integerLiteral ||\n            node.type === nodeTypes.floatLiteral\n        );\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","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 { EnergyViolation, VIOLATION_TYPE, SEVERITY } from '../../types';\nimport { PositionLookup } from '../position';\nimport { LanguageAdapter } from '../language';\n\n// The \"Opaque Boolean Literal\" detector: a bare `true`/`false` passed positionally\n// into a call gives the reader no information about what it means without tracing\n// into the callee's signature — unlike primitive-obsession's swap-risk check, this\n// doesn't need a second adjacent parameter to be a problem; one opaque literal is\n// enough. Naming it at the call site (whatever the language allows: a keyword\n// argument, an object-literal field, F#'s named-argument syntax) fixes the\n// readability problem even where it isn't enforced by the type checker — see\n// isPositionalCallArgument's per-language doc for how each grammar distinguishes\n// labeled from positional.\nfunction buildViolation(node: any, positions: PositionLookup): EnergyViolation {\n    const position = positions.toPosition(node.startIndex);\n    return {\n        line: position.line,\n        column: position.column,\n        type: VIOLATION_TYPE.OPAQUE_BOOLEAN,\n        severity: SEVERITY.LOW,\n        message: `Opaque boolean literal: a bare '${node.text}' passed positionally tells the reader nothing without checking the callee's signature. Name it at the call site (a keyword argument, an object-literal field, or F#'s named-argument syntax) — or better, split into two clearly named functions (e.g. enableX()/disableX()) or use an enum.`\n    };\n}\n\nexport function analyzeOpaqueBooleanLiteral(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): EnergyViolation[] {\n    const violations: EnergyViolation[] = [];\n\n    function traverse(node: any) {\n        if (language.isBooleanLiteral(node) && language.isPositionalCallArgument(node)) {\n            violations.push(buildViolation(node, positions));\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// 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(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): 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';\nimport { findParametersNode } from './parameterCount';\n\ninterface TypedParam {\n    name: string;\n    type: string;\n    node: any;\n    keywordOnly: boolean;\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.\n//\n// decision: a pair is suppressed only when BOTH params sit past a\n// keywordOnlyBoundaryTypes marker (Python's bare `*` / `*args`) — the signature\n// itself must make positional calls impossible, not just \"some call sites happen\n// to use keywords\". A signature that still allows positional calls will\n// eventually get one.\n// known gap: Python's `**kwargs` dict-splatting can reintroduce positional-style\n// swap risk even past a keyword-only boundary (a caller building the dict by\n// hand can still transpose the values) — not worth detecting, left undocumented\n// in code but called out here for future readers.\nfunction findParameterCollisions(\n    paramsNode: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): EnergyViolation[] {\n    const violations: EnergyViolation[] = [];\n    let keywordOnly = false;\n    const typed: TypedParam[] = [];\n    for (const n of paramsNode.children) {\n        if (language.keywordOnlyBoundaryTypes.includes(n.type)) {\n            keywordOnly = true;\n            continue;\n        }\n        const extracted = language.extractTypedParameter(n);\n        if (extracted) {\n            typed.push({ ...extracted, node: n, keywordOnly });\n        }\n    }\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            continue;\n        }\n        if (a.keywordOnly && b.keywordOnly) {\n            continue;\n        }\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 ${language.distinctTypeAdvice} so the type checker catches it.`\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(\n    functionNode: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): 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(\n    tree: any,\n    positions: PositionLookup,\n    language: LanguageAdapter\n): 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","import * as fs from 'fs';\nimport * as path from 'path';\n\n// .esaignore holds one path pattern per line, relative to the file's own directory (the\n// project root, by convention — same as .gitignore). Blank lines and lines starting with\n// '#' are skipped.\n//\n// decision: supports exactly two pattern shapes — a literal path/directory (matches\n// itself, and everything under it if it's a directory; a bare name with no '/' also\n// matches at any depth, like gitignore) and a single-segment basename glob containing '*'\n// (e.g. `*.generated.ts`) — not a full gitignore engine (no negation, no '**', no brace\n// expansion), matching scan.ts's existing minimal-glob philosophy (see its\n// expandGlobLike) rather than pulling in a dependency.\nexport const ESAIGNORE_FILENAME = '.esaignore';\n\nexport function loadIgnorePatterns(rootDir: string): string[] {\n    const ignorePath = path.join(rootDir, ESAIGNORE_FILENAME);\n    if (!fs.existsSync(ignorePath)) {\n        return [];\n    }\n    return fs\n        .readFileSync(ignorePath, 'utf8')\n        .split('\\n')\n        .map((line) => line.trim())\n        .filter((line) => line.length > 0 && !line.startsWith('#'))\n        .map((line) => line.replace(/\\/+$/, ''));\n}\n\nfunction matchesLiteralPattern(relPath: string, pattern: string): boolean {\n    if (pattern.includes('/')) {\n        return relPath === pattern || relPath.startsWith(`${pattern}/`);\n    }\n    return relPath.split('/').includes(pattern);\n}\n\nfunction basenameGlobToRegExp(pattern: string): RegExp {\n    const escaped = pattern\n        .split('*')\n        .map((part) => part.replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&'))\n        .join('.*');\n    return new RegExp(`^${escaped}$`);\n}\n\n// Whether `absolutePath` (a file or directory) matches any pattern loaded via\n// loadIgnorePatterns, rooted at `rootDir`.\nexport function isIgnored(absolutePath: string, rootDir: string, patterns: string[]): boolean {\n    if (patterns.length === 0) {\n        return false;\n    }\n    const relPath = path.relative(rootDir, absolutePath).split(path.sep).join('/');\n    const basename = path.basename(absolutePath);\n\n    return patterns.some((pattern) =>\n        pattern.includes('*') ? basenameGlobToRegExp(pattern).test(basename) : matchesLiteralPattern(relPath, pattern)\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","import { EnergyViolation } from '../types';\nimport { SeverityCounts, emptyCounts } from './severityCounts';\n\n// invariant: this module must not import fs/child_process/vscode — it only aggregates and\n// renders data the caller already has, so it stays testable with hand-built fixtures\n// (see src/test/integration/report.test.ts) and reusable from both the CLI's scan and diff modes\n//\n// decision: split into report.ts (aggregate scoring + markdown table), reportDiff.ts (base/head\n// diffing), and reportHuman.ts (the human-readable risk report) — the combined file had grown to\n// 16 functions across three largely independent domains, which is exactly the sprawl this tool's\n// own coherence detector flags. This file re-exports the other two so existing imports of\n// './report' keep working unchanged.\n\nexport interface FileResult {\n    filePath: string;\n    violations: EnergyViolation[];\n}\n\nexport type { SeverityCounts };\n\nexport interface FileSummary {\n    filePath: string;\n    score: number;\n    counts: SeverityCounts;\n    byType: Record<string, number>;\n}\n\nexport interface AggregateSummary {\n    files: FileSummary[];\n    totalScore: number;\n    totalCounts: SeverityCounts;\n}\n\n// decision: weights (1/4/9) make high-severity violations dominate the score without parsing\n// numeric complexity out of detector message strings — see src/core/detectors/cyclomatic.ts and\n// cognitive.ts, which only embed their numeric complexity in `message`, not as a structured field.\n// invariant: these weights are load-bearing for diff continuity (diffSummaries below) — changing\n// them changes the meaning of a previously reported delta, so treat this as a versioned constant.\nconst SEVERITY_WEIGHT: SeverityCounts = { low: 1, medium: 4, high: 9 };\n\nexport function summarizeFile(result: FileResult): FileSummary {\n    const counts = emptyCounts();\n    const byType: Record<string, number> = {};\n\n    for (const violation of result.violations) {\n        counts[violation.severity] += 1;\n        byType[violation.type] = (byType[violation.type] ?? 0) + 1;\n    }\n\n    const score =\n        counts.low * SEVERITY_WEIGHT.low + counts.medium * SEVERITY_WEIGHT.medium + counts.high * SEVERITY_WEIGHT.high;\n\n    return { filePath: result.filePath, score, counts, byType };\n}\n\nexport function summarize(results: FileResult[]): AggregateSummary {\n    const files = results.map(summarizeFile);\n    const totalCounts = emptyCounts();\n    let totalScore = 0;\n\n    for (const file of files) {\n        totalScore += file.score;\n        totalCounts.low += file.counts.low;\n        totalCounts.medium += file.counts.medium;\n        totalCounts.high += file.counts.high;\n    }\n\n    return { files, totalScore, totalCounts };\n}\n\nexport function hasBlockingViolations(counts: SeverityCounts): boolean {\n    return counts.medium > 0 || counts.high > 0;\n}\n\nexport function renderMarkdownReport(summary: AggregateSummary): string {\n    const cleanCount = summary.files.filter((f) => f.score === 0).length;\n    const lines: string[] = [];\n\n    lines.push('# Energy State Report');\n    lines.push('');\n    lines.push(\n        `**${summary.files.length} file${summary.files.length === 1 ? '' : 's'} scanned** — ${cleanCount} clean, ${summary.files.length - cleanCount} with violations`\n    );\n    lines.push('');\n    lines.push('| File | Score | High | Medium | Low |');\n    lines.push('| --- | --- | --- | --- | --- |');\n\n    for (const file of summary.files) {\n        lines.push(\n            `| ${file.filePath} | ${file.score} | ${file.counts.high} | ${file.counts.medium} | ${file.counts.low} |`\n        );\n    }\n\n    lines.push('');\n    lines.push(\n        `**Total score: ${summary.totalScore}** (${summary.totalCounts.high} high, ${summary.totalCounts.medium} medium, ${summary.totalCounts.low} low)`\n    );\n\n    return lines.join('\\n');\n}\n\nexport * from './reportDiff';\nexport * from './reportHuman';\n","// decision: split out of report.ts (base/head diffing and its markdown rendering) so the\n// aggregate-scoring, diff, and human-report domains each live in their own file — see the\n// coherence note in report.ts\nimport type { FileSummary } from './report';\n\nexport interface DiffEntry {\n    filePath: string;\n    baseScore: number | null;\n    headScore: number;\n    delta: number;\n    status: 'new' | 'improved' | 'worsened' | 'unchanged';\n}\n\n// decision: keyed by filePath so callers can pass base/head summaries independently sized -\n// a file present only in head (baseScore null) is reported as 'new' rather than dropped\nexport function diffSummaries(base: FileSummary[], head: FileSummary[]): DiffEntry[] {\n    const baseByPath = new Map(base.map((f) => [f.filePath, f.score]));\n\n    return head.map((file) => {\n        const baseScore = baseByPath.get(file.filePath) ?? null;\n        const delta = baseScore === null ? file.score : file.score - baseScore;\n        const status: DiffEntry['status'] =\n            baseScore === null ? 'new' : delta < 0 ? 'improved' : delta > 0 ? 'worsened' : 'unchanged';\n\n        return { filePath: file.filePath, baseScore, headScore: file.score, delta, status };\n    });\n}\n\nconst STATUS_ICON: Record<DiffEntry['status'], string> = {\n    new: '🆕',\n    improved: '🟢',\n    worsened: '🔴',\n    unchanged: '⚪'\n};\n\nconst EMPTY_STATUS_COUNTS: Record<DiffEntry['status'], number> = { new: 0, improved: 0, worsened: 0, unchanged: 0 };\n\nexport function renderDiffMarkdown(entries: DiffEntry[], baseRef: string): string {\n    const lines: string[] = [];\n\n    lines.push(`# Energy State Diff vs \\`${baseRef}\\``);\n    lines.push('');\n    lines.push('| File | Base | Head | Δ | Status |');\n    lines.push('| --- | --- | --- | --- | --- |');\n\n    for (const entry of entries) {\n        const base = entry.baseScore === null ? '—' : String(entry.baseScore);\n        const delta = entry.baseScore === null ? '—' : entry.delta > 0 ? `+${entry.delta}` : String(entry.delta);\n        lines.push(\n            `| ${entry.filePath} | ${base} | ${entry.headScore} | ${delta} | ${STATUS_ICON[entry.status]} ${entry.status} |`\n        );\n    }\n\n    // decision: tallies every status in one pass over a Record rather than three separate\n    // `entries.filter(e => e.status === '...').length` calls — besides being cheaper, it avoids\n    // repeating e.status against string literals, which the primitive-obsession detector reads\n    // as stringly-typed control flow even though DiffEntry['status'] is already a literal union\n    const statusCounts = entries.reduce(\n        (counts, entry) => {\n            counts[entry.status] += 1;\n            return counts;\n        },\n        { ...EMPTY_STATUS_COUNTS }\n    );\n\n    lines.push('');\n    lines.push(\n        `_${entries.length} file${entries.length === 1 ? '' : 's'} changed, ${statusCounts.worsened} worsened, ${statusCounts.improved} improved, ${statusCounts.new} new._`\n    );\n\n    return lines.join('\\n');\n}\n","// decision: split out of report.ts (the human-readable risk report) so the aggregate-scoring,\n// diff, and human-report domains each live in their own file — see the coherence note in\n// report.ts\n//\n// decision: risk is reported on a None/Low/Medium/High/Critical qualitative scale rather than\n// a bespoke label set of our own — it mirrors the levels the existing SEVERITY constants already\n// use, just extended to five tiers, so a reader doesn't have to learn a new vocabulary. Earlier\n// this scale was explicitly framed as CVSS (the vulnerability-scoring standard); that framing was\n// dropped because it made readers think \"why is my code getting a CVE score\", which is the\n// opposite of a scale they should already be able to reason about.\n// decision: the underlying 0.0-10.0 complexity score is a piecewise-linear mapping of\n// the raw complexity number, anchored at README's existing McCabe breakpoints (10/20/50) —\n// see complexityToScore below — so the label is a re-expression of the same,\n// already-documented complexity bands rather than a second, independently-calibrated scale.\n// decision: a file's/report's headline risk is the MAXIMUM complexity value found, not an\n// average — averaging a file's function complexities would let one severely complex function\n// hide behind many trivial ones (nine functions at complexity 2 and one at 60 averages to ~8,\n// \"Low\"), masking exactly the function worth fixing first. Violation *counts* are reported\n// separately as a breadth indicator, deliberately not folded into the same number — this\n// mirrors the README's own Energy (peak intensity) vs Entropy (how spread out) distinction.\nimport { EnergyViolation, SEVERITY, VIOLATION_TYPE } from '../types';\nimport { emptyCounts } from './severityCounts';\nimport type { FileResult } from './report';\n\nexport type RiskLevel = 'none' | 'low' | 'medium' | 'high' | 'critical';\n\n// decision: anchors (value, score) pairs at the exact breakpoints README already documents\n// for cyclomatic complexity (10/20/50), reusing CVSS v3.1's qualitative boundaries\n// (3.9/6.9/8.9/10.0) as the corresponding output scores purely as a convenient 0-10 curve\n// shape — no CVSS terminology is surfaced to the reader — then linearly interpolates between\n// anchors and caps at complexity 100+ = 10.0\n// decision: the anchor scores are deliberately 0.1 below classifyScore's cutoffs (3.9 not 4.0,\n// 6.9 not 7.0, 8.9 not 9.0), not rounded to whole numbers — a complexity of exactly 10/20/50 is\n// the top of its documented band (10 = top of Low, per README), so its score must land just\n// under the next band's cutoff to classify correctly. Rounding these to 4.0/7.0/9.0 would push\n// complexity exactly 10/20/50 into the next band up, silently relabeling the documented\n// breakpoints themselves.\nconst COMPLEXITY_CURVE: { value: number; score: number }[] = [\n    { value: 0, score: 0.0 },\n    { value: 10, score: 3.9 },\n    { value: 20, score: 6.9 },\n    { value: 50, score: 8.9 },\n    { value: 100, score: 10.0 }\n];\n\n// decision: derived from COMPLEXITY_CURVE's own last anchor rather than re-hardcoded — the cap\n// this function returns for out-of-range input must always agree with the curve it's capping\nconst MAX_COMPLEXITY_VALUE = COMPLEXITY_CURVE[COMPLEXITY_CURVE.length - 1].value;\nconst MAX_COMPLEXITY_SCORE = COMPLEXITY_CURVE[COMPLEXITY_CURVE.length - 1].score;\nconst SCORE_DECIMAL_PRECISION = 10;\n\nexport function complexityToScore(value: number): number {\n    if (value <= 0) {\n        return 0;\n    }\n    if (value >= MAX_COMPLEXITY_VALUE) {\n        return MAX_COMPLEXITY_SCORE;\n    }\n    for (let i = 1; i < COMPLEXITY_CURVE.length; i++) {\n        const prev = COMPLEXITY_CURVE[i - 1];\n        const next = COMPLEXITY_CURVE[i];\n        if (value <= next.value) {\n            const ratio = (value - prev.value) / (next.value - prev.value);\n            return (\n                Math.round((prev.score + ratio * (next.score - prev.score)) * SCORE_DECIMAL_PRECISION) /\n                SCORE_DECIMAL_PRECISION\n            );\n        }\n    }\n    return MAX_COMPLEXITY_SCORE;\n}\n\n// decision: boundaries reuse CVSS v3.1's qualitative rating cutoffs as a scale shape\n// (None 0.0, Low 0.1-3.9, Medium 4.0-6.9, High 7.0-8.9, Critical 9.0-10.0) without labeling\n// the scale itself as CVSS anywhere the reader sees it\nconst RISK_SCORE_CUTOFF: Record<'low' | 'medium' | 'high', number> = {\n    low: 4.0,\n    medium: 7.0,\n    high: 9.0\n};\n\nexport function classifyScore(score: number): RiskLevel {\n    if (score <= 0) {\n        return 'none';\n    }\n    if (score < RISK_SCORE_CUTOFF.low) {\n        return 'low';\n    }\n    if (score < RISK_SCORE_CUTOFF.medium) {\n        return 'medium';\n    }\n    if (score < RISK_SCORE_CUTOFF.high) {\n        return 'high';\n    }\n    return 'critical';\n}\n\nexport function classifyComplexityScore(value: number): RiskLevel {\n    return classifyScore(complexityToScore(value));\n}\n\nconst RISK_LABEL: Record<RiskLevel, string> = {\n    none: 'None',\n    low: 'Low',\n    medium: 'Medium',\n    high: 'High',\n    critical: 'Critical'\n};\n\nconst RISK_DESCRIPTION: Record<RiskLevel, string> = {\n    none: 'no violations found',\n    low: 'simple, easy to test exhaustively',\n    medium: 'getting harder to cover with tests',\n    high: 'complex, testing all paths is impractical',\n    critical: 'effectively untestable'\n};\n\nconst CATEGORY_LABEL: Record<string, string> = {\n    [VIOLATION_TYPE.NESTING]: 'Nesting depth',\n    [VIOLATION_TYPE.COMPLEXITY]: 'Cyclomatic complexity',\n    [VIOLATION_TYPE.COGNITIVE]: 'Cognitive complexity',\n    [VIOLATION_TYPE.NAMING]: 'Naming',\n    [VIOLATION_TYPE.COHERENCE]: 'File coherence',\n    [VIOLATION_TYPE.MAGIC]: 'Magic values',\n    [VIOLATION_TYPE.PARAMETERS]: 'Parameter count',\n    [VIOLATION_TYPE.INVERSION]: 'Inversion opportunities',\n    [VIOLATION_TYPE.PRIMITIVE_OBSESSION]: 'Primitive obsession',\n    [VIOLATION_TYPE.MATCH_OPPORTUNITY]: 'Match opportunities',\n    [VIOLATION_TYPE.LOGICAL_CONTROL_FLOW]: 'Logical operator as control flow',\n    [VIOLATION_TYPE.OPAQUE_BOOLEAN]: 'Opaque boolean literals',\n    [VIOLATION_TYPE.SUPPRESSION]: 'Suppression directives'\n};\n\n// decision: only the non-complexity categories get a static blurb — cyclomatic/cognitive\n// findings are described from their own extracted numbers instead (see describeCategory)\nconst CATEGORY_BLURB: Record<string, string> = {\n    [VIOLATION_TYPE.NESTING]:\n        'control-flow blocks nested deep enough that a reader has to hold several levels of context in mind at once',\n    [VIOLATION_TYPE.NAMING]: 'naming that obscures intent',\n    [VIOLATION_TYPE.COHERENCE]:\n        'the file mixes too many responsibilities (too many functions/imports, or too many large functions) to read as one coherent unit',\n    [VIOLATION_TYPE.MAGIC]: 'unnamed literals standing in for a value that deserves a name',\n    [VIOLATION_TYPE.PARAMETERS]: 'a function with enough parameters that call sites are easy to get wrong',\n    [VIOLATION_TYPE.INVERSION]: 'validation/guard logic that would read more clearly as early returns',\n    [VIOLATION_TYPE.PRIMITIVE_OBSESSION]:\n        'adjacent same-typed values a caller could silently swap without the compiler noticing',\n    [VIOLATION_TYPE.MATCH_OPPORTUNITY]:\n        'an if/elif chain on one variable that would read more clearly as a match/switch',\n    [VIOLATION_TYPE.LOGICAL_CONTROL_FLOW]: '&&/|| used to hide an if statement',\n    [VIOLATION_TYPE.OPAQUE_BOOLEAN]: 'a bare true/false at a call site that only makes sense by reading the callee',\n    [VIOLATION_TYPE.SUPPRESSION]: 'an esa-ignore comment that names an unknown violation type, or no longer matches any violation'\n};\n\nconst COMPLEXITY_VALUE_PATTERN = /complexity: (\\d+)/i;\n\n// decision: extracts the numeric complexity from the violation message rather than adding a\n// structured field to EnergyViolation — see cyclomatic.ts/cognitive.ts, whose message format\n// (`High {cyclomatic|cognitive} complexity: N. ...`) is the only place that number lives today,\n// and both messages are only emitted above their own mediumThreshold, so any match is meaningful\nfunction extractComplexityValue(violation: EnergyViolation): number | undefined {\n    if (violation.type !== VIOLATION_TYPE.COMPLEXITY && violation.type !== VIOLATION_TYPE.COGNITIVE) {\n        return undefined;\n    }\n    const match = violation.message.match(COMPLEXITY_VALUE_PATTERN);\n    return match ? Number(match[1]) : undefined;\n}\n\nfunction describeComplexityFindings(label: string, violations: EnergyViolation[]): string {\n    const values = violations\n        .map(extractComplexityValue)\n        .filter((value): value is number => value !== undefined)\n        .sort((a, b) => b - a);\n\n    if (values.length === 0) {\n        return '';\n    }\n\n    const worst = values[0];\n    const score = complexityToScore(worst);\n    const level = classifyScore(score);\n    const countText =\n        values.length === 1\n            ? `1 function scores ${worst}`\n            : `${values.length} functions score ${values.join(', ')} (worst: ${worst})`;\n\n    return `- **${label}**: ${countText} — score ${score.toFixed(1)} (${RISK_LABEL[level]}): ${RISK_DESCRIPTION[level]}.`;\n}\n\nfunction describeCategoryFindings(type: string, violations: EnergyViolation[]): string {\n    const label = CATEGORY_LABEL[type] ?? type;\n\n    if (type === VIOLATION_TYPE.COMPLEXITY || type === VIOLATION_TYPE.COGNITIVE) {\n        return describeComplexityFindings(label, violations);\n    }\n\n    const counts = emptyCounts();\n    for (const violation of violations) {\n        counts[violation.severity] += 1;\n    }\n    const severityText = (['high', 'medium', 'low'] as const)\n        .filter((severity) => counts[severity] > 0)\n        .map((severity) => `${counts[severity]} ${severity}`)\n        .join(', ');\n    const blurb = CATEGORY_BLURB[type];\n\n    return `- **${label}**: ${violations.length} finding${violations.length === 1 ? '' : 's'} (${severityText})${blurb ? ` — ${blurb}` : ''}.`;\n}\n\n// decision: falls back to a fixed severity-based score when a file has no cyclomatic/cognitive\n// violations at all — those detectors don't fire on every file, but a file full of high-severity\n// findings from other detectors still deserves a non-zero score.\n// invariant: the fallback never reaches Critical (score < 9.0) — Critical is reserved for genuinely\n// extreme complexity (>=~93 on the interpolated curve), not for a pattern-based detector's severity\nconst FALLBACK_SEVERITY_SCORE: Record<'high' | 'medium' | 'low', number> = {\n    high: 7.5,\n    medium: 5.0,\n    low: 2.0\n};\n\nfunction fileScore(violations: EnergyViolation[]): number {\n    const complexityValues = violations\n        .map(extractComplexityValue)\n        .filter((value): value is number => value !== undefined);\n\n    if (complexityValues.length > 0) {\n        return complexityToScore(Math.max(...complexityValues));\n    }\n    if (violations.some((v) => v.severity === SEVERITY.HIGH)) {\n        return FALLBACK_SEVERITY_SCORE.high;\n    }\n    if (violations.some((v) => v.severity === SEVERITY.MEDIUM)) {\n        return FALLBACK_SEVERITY_SCORE.medium;\n    }\n    if (violations.length > 0) {\n        return FALLBACK_SEVERITY_SCORE.low;\n    }\n    return 0.0;\n}\n\nfunction renderFileSection(result: FileResult): string {\n    const lines: string[] = [];\n    const score = fileScore(result.violations);\n    const risk = classifyScore(score);\n\n    lines.push(`## ${result.filePath} — ${RISK_LABEL[risk]} (score ${score.toFixed(1)})`);\n    lines.push('');\n\n    const byType = new Map<string, EnergyViolation[]>();\n    for (const violation of result.violations) {\n        const list = byType.get(violation.type) ?? [];\n        list.push(violation);\n        byType.set(violation.type, list);\n    }\n\n    for (const [type, violations] of byType) {\n        const description = describeCategoryFindings(type, violations);\n        if (description) {\n            lines.push(description);\n        }\n    }\n\n    return lines.join('\\n');\n}\n\nconst SCORE_LEGEND = [\n    '## Score legend',\n    '',\n    '_Risk is reported on a 0.0–10.0 complexity score, sorted into the same None/Low/Medium/High/Critical levels already used elsewhere in this tool._',\n    '',\n    '| Score | Risk | Roughly | Cyclomatic/cognitive complexity |',\n    '| --- | --- | --- | --- |',\n    '| 0.0 | None | No violations found | — |',\n    '| 0.1–3.9 | Low | Simple, easy to test exhaustively | 1–10 |',\n    '| 4.0–6.9 | Medium | Getting harder to cover with tests | 11–20 |',\n    '| 7.0–8.9 | High | Complex, testing all paths is impractical | 21–50 |',\n    '| 9.0–10.0 | Critical | Effectively untestable | 50+ |',\n    '',\n    '_Cyclomatic and cognitive complexity numbers are converted to the score using the ranges above. Other detectors flag a pattern rather than a path count, so a file with no complexity violations of its own instead gets a fixed score from its worst other finding (Low 2.0 / Medium 5.0 / High 7.5)._'\n].join('\\n');\n\nexport function renderHumanReport(results: FileResult[]): string {\n    const flagged = results\n        .filter((r) => r.violations.length > 0)\n        .sort((a, b) => fileScore(b.violations) - fileScore(a.violations));\n    const cleanCount = results.length - flagged.length;\n\n    const lines: string[] = [];\n    lines.push('# Energy State Report');\n    lines.push('');\n    lines.push(SCORE_LEGEND);\n    lines.push('');\n    lines.push(\n        `**${results.length} file${results.length === 1 ? '' : 's'} scanned** — ${cleanCount} clean, ${flagged.length} flagged`\n    );\n    lines.push('');\n\n    for (const result of flagged) {\n        lines.push(renderFileSection(result));\n        lines.push('');\n    }\n\n    lines.push('## Total evaluation');\n    lines.push('');\n\n    const fileScores = results.map((r) => ({ filePath: r.filePath, score: fileScore(r.violations) }));\n    const worst = fileScores.reduce((a, b) => (b.score > a.score ? b : a), { filePath: '', score: 0 });\n    const repoLevel = classifyScore(worst.score);\n\n    if (worst.score > 0) {\n        lines.push(\n            `**Repo score: ${worst.score.toFixed(1)} (${RISK_LABEL[repoLevel]})** — driven by the worst file in the scan, \\`${worst.filePath}\\` (${RISK_DESCRIPTION[repoLevel]}).`\n        );\n    } else {\n        lines.push('**Repo score: 0.0 (None)** — no violations were found anywhere in the scan.');\n    }\n    lines.push('');\n    lines.push(\n        'This is the _maximum_ file score, not an average across files — see the note at the top of this report for why an average would hide the file most worth fixing.'\n    );\n    lines.push('');\n\n    const riskCounts: Record<RiskLevel, number> = { none: 0, low: 0, medium: 0, high: 0, critical: 0 };\n    for (const { score } of fileScores) {\n        riskCounts[classifyScore(score)] += 1;\n    }\n\n    lines.push('| Risk | Files |');\n    lines.push('| --- | --- |');\n    lines.push(`| None | ${riskCounts.none} |`);\n    lines.push(`| Low | ${riskCounts.low} |`);\n    lines.push(`| Medium | ${riskCounts.medium} |`);\n    lines.push(`| High | ${riskCounts.high} |`);\n    lines.push(`| Critical | ${riskCounts.critical} |`);\n    lines.push('');\n\n    const totalCounts = emptyCounts();\n    for (const result of results) {\n        for (const violation of result.violations) {\n            totalCounts[violation.severity] += 1;\n        }\n    }\n    const totalFindings = totalCounts.low + totalCounts.medium + totalCounts.high;\n    lines.push(\n        `**${totalFindings} total finding${totalFindings === 1 ? '' : 's'}** (${totalCounts.high} high, ${totalCounts.medium} medium, ${totalCounts.low} low) — breadth of issues across the scan, independent of peak severity.`\n    );\n\n    return lines.join('\\n');\n}\n","import * as fs from 'fs';\nimport * as path from 'path';\n\nimport { resolveLanguageForFile } from '../languages';\nimport { isIgnored, loadIgnorePatterns } from './esaignore';\n\n// invariant: this module only touches the filesystem (fs/path) — no tree-sitter, no vscode,\n// no git — so it stays independently testable against src/test/fixtures\n\nconst IGNORED_DIR_NAMES = new Set([\n    'node_modules',\n    '.git',\n    'dist',\n    'out',\n    'build',\n    '.next',\n    'coverage',\n    '.vscode-test'\n]);\n\n// decision: bundles rootDir + ignorePatterns rather than passing them as two adjacent\n// string/string[] parameters — they always travel together, and rootDir sitting next to\n// another string parameter (dir, pattern) at each call site is exactly the swap-risk shape\n// the primitive-obsession detector flags (two consecutive same-typed params a caller could\n// transpose without the type checker complaining)\ninterface IgnoreContext {\n    rootDir: string;\n    ignorePatterns: string[];\n}\n\nfunction isPathIgnored(targetPath: string, ignore: IgnoreContext): boolean {\n    return isIgnored(targetPath, ignore.rootDir, ignore.ignorePatterns);\n}\n\nfunction walkDirectory(dir: string, ignore: IgnoreContext, results: string[]): void {\n    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {\n        const fullPath = path.join(dir, entry.name);\n        if (IGNORED_DIR_NAMES.has(entry.name) || isPathIgnored(fullPath, ignore)) {\n            continue;\n        }\n        if (entry.isDirectory()) {\n            walkDirectory(fullPath, ignore, results);\n        } else if (entry.isFile() && resolveLanguageForFile(entry.name)) {\n            results.push(fullPath);\n        }\n    }\n}\n\n// decision: supports exactly one glob shape — a trailing `**/*.ext`-style suffix on an\n// otherwise literal directory prefix — rather than pulling in a general glob-matching\n// dependency. This covers the common \"src/**/*.py\" case; anything with brace expansion,\n// negation, or mid-path wildcards is not a glob engine this function implements.\nfunction expandGlobLike(pattern: string, ignore: IgnoreContext): string[] {\n    const starIndex = pattern.indexOf('*');\n    const prefixEnd = pattern.lastIndexOf(path.sep, starIndex);\n    const prefixDir = prefixEnd === -1 ? '.' : pattern.slice(0, prefixEnd);\n    const suffix = pattern.slice(pattern.lastIndexOf('.'));\n    const extension = suffix.startsWith('.') && !suffix.includes('*') ? suffix : undefined;\n\n    if (!fs.existsSync(prefixDir) || !fs.statSync(prefixDir).isDirectory()) {\n        return [];\n    }\n\n    const results: string[] = [];\n    walkDirectory(prefixDir, ignore, results);\n    return extension ? results.filter((file) => file.toLowerCase().endsWith(extension.toLowerCase())) : results;\n}\n\n// Expands file/directory/glob-like CLI arguments into a deduplicated, sorted list of\n// absolute paths to files with a supported extension (see resolveLanguageForFile),\n// excluding anything matched by a `.esaignore` file found in `rootDir` (defaults to the\n// current working directory, mirroring where a CLI invocation expects to find it).\nexport function resolveSupportedFiles(inputs: string[], rootDir: string = process.cwd()): string[] {\n    const ignore: IgnoreContext = { rootDir, ignorePatterns: loadIgnorePatterns(rootDir) };\n    const results: string[] = [];\n\n    for (const input of inputs) {\n        if (input.includes('*')) {\n            results.push(...expandGlobLike(input, ignore));\n            continue;\n        }\n\n        if (!fs.existsSync(input)) {\n            continue;\n        }\n\n        const stat = fs.statSync(input);\n        if (stat.isDirectory()) {\n            if (!isPathIgnored(input, ignore)) {\n                walkDirectory(input, ignore, results);\n            }\n        } else if (stat.isFile() && resolveLanguageForFile(input) && !isPathIgnored(input, ignore)) {\n            results.push(input);\n        }\n    }\n\n    const absolute = results.map((file) => path.resolve(file));\n    return Array.from(new Set(absolute)).sort();\n}\n","// decision: split out of report.ts so the low/medium/high tally shape and its zero-value\n// constructor can be shared by report.ts's aggregate scoring and reportHuman.ts's human-readable\n// rendering without either module importing the other (see report.ts for the coherence split)\nexport type SeverityCounts = Record<'low' | 'medium' | 'high', number>;\n\nexport function emptyCounts(): SeverityCounts {\n    return { low: 0, medium: 0, high: 0 };\n}\n","import { EnergyViolation, VIOLATION_TYPE } from '../types';\n\n// decision: parsed by scanning raw source lines with a regex instead of walking the tree-sitter\n// AST — the comment node type differs per grammar (see LanguageAdapter.nodeTypes.comment) but the\n// esa-ignore marker text itself is identical across languages, so a text scan avoids needing a\n// per-language comment-node lookup just to find `//` and `#` comments.\nconst DIRECTIVE_PATTERN = /(\\/\\/|#)\\s*esa-ignore(-file)?(?::\\s*([\\w,\\s-]+))?/;\n\nconst KNOWN_TYPES: Set<string> = new Set(Object.values(VIOLATION_TYPE));\n\nexport interface Suppression {\n    // 0-indexed line the directive comment itself sits on (matches EnergyViolation.line).\n    line: number;\n    column: number;\n    scope: 'line' | 'file';\n    types: string[] | 'all';\n    unknownTypes: string[];\n    // Whether the directive is the only content on its line — see isCoveredBy below.\n    standalone: boolean;\n}\n\n// decision: an explicit but entirely-unrecognized type list (e.g. a typo'd `esa-ignore:\n// nseting`) resolves to an empty list, not a fallback to 'all' — falling back to 'all' would\n// make a typo silently suppress *more* than intended instead of less, which is the opposite of\n// the \"keep suppression honest\" goal (see the unused-directive note this produces below). Only\n// a bare directive with no colon at all means \"suppress every type\".\nfunction parseTypeList(raw: string | undefined): { types: string[] | 'all'; unknownTypes: string[] } {\n    if (!raw) {\n        return { types: 'all', unknownTypes: [] };\n    }\n    const tokens = raw.split(',').map(token => token.trim()).filter(Boolean);\n    const types = tokens.filter(token => KNOWN_TYPES.has(token));\n    const unknownTypes = tokens.filter(token => !KNOWN_TYPES.has(token));\n    return { types, unknownTypes };\n}\n\nexport function parseSuppressions(sourceText: string): Suppression[] {\n    const lines = sourceText.split('\\n');\n    const suppressions: Suppression[] = [];\n\n    lines.forEach((lineText, line) => {\n        const match = DIRECTIVE_PATTERN.exec(lineText);\n        if (!match) {\n            return;\n        }\n        const { types, unknownTypes } = parseTypeList(match[3]);\n        suppressions.push({\n            line,\n            column: match.index,\n            scope: match[2] ? 'file' : 'line',\n            types,\n            unknownTypes,\n            standalone: lineText.slice(0, match.index).trim() === ''\n        });\n    });\n\n    return suppressions;\n}\n\n// decision: a standalone directive (nothing but the comment on its line) also covers the next\n// line — lets a suppression read naturally placed above a multi-line construct's header (a\n// function signature, an if-condition) instead of forcing it onto an already-long code line.\nfunction coversLine(suppression: Suppression, violationLine: number): boolean {\n    if (suppression.scope === 'file') {\n        return true;\n    }\n    if (violationLine === suppression.line) {\n        return true;\n    }\n    return suppression.standalone && violationLine === suppression.line + 1;\n}\n\nfunction matchesType(suppression: Suppression, type: string): boolean {\n    return suppression.types === 'all' || suppression.types.includes(type);\n}\n\nexport interface ApplySuppressionsResult {\n    violations: EnergyViolation[];\n    suppressionNotes: EnergyViolation[];\n}\n\n// decision: returns unused/unknown-type directives as their own low-severity violations (rather\n// than silently dropping them) — an esa-ignore that stopped matching anything (the violation was\n// fixed, or the type name was mistyped) is exactly the kind of stale suppression that should be\n// visible, not a silent no-op that quietly keeps working \"by accident\".\nexport function applySuppressions(violations: EnergyViolation[], sourceText: string): ApplySuppressionsResult {\n    const suppressions = parseSuppressions(sourceText);\n    if (suppressions.length === 0) {\n        return { violations, suppressionNotes: [] };\n    }\n\n    const suppressedCounts = new Map<Suppression, number>(suppressions.map(s => [s, 0]));\n\n    const remaining = violations.filter(violation => {\n        const match = suppressions.find(s => coversLine(s, violation.line) && matchesType(s, violation.type));\n        if (!match) {\n            return true;\n        }\n        suppressedCounts.set(match, (suppressedCounts.get(match) ?? 0) + 1);\n        return false;\n    });\n\n    const suppressionNotes: EnergyViolation[] = [];\n    for (const suppression of suppressions) {\n        if (suppression.unknownTypes.length > 0) {\n            suppressionNotes.push({\n                line: suppression.line,\n                column: suppression.column,\n                type: VIOLATION_TYPE.SUPPRESSION,\n                severity: 'low',\n                message: `esa-ignore names unknown violation type(s): ${suppression.unknownTypes.join(', ')}.`\n            });\n        }\n        if ((suppressedCounts.get(suppression) ?? 0) === 0) {\n            const scopeText = suppression.scope === 'file' ? 'file-wide ' : '';\n            suppressionNotes.push({\n                line: suppression.line,\n                column: suppression.column,\n                type: VIOLATION_TYPE.SUPPRESSION,\n                severity: 'low',\n                message: `Unused ${scopeText}esa-ignore — no matching violation found. Remove it or fix the type list.`\n            });\n        }\n    }\n\n    return { violations: remaining, suppressionNotes };\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 (\n            node?.type === 'function_or_value_defn' &&\n            node.children?.some((child: any) => child.type === 'function_declaration_left')\n        );\n    },\n    parameterChildTypes: ['long_identifier', 'typed_pattern'],\n    decisionNodeTypes: [\n        'if_expression',\n        'elif_expression',\n        'for_expression',\n        'while_expression',\n        'try_expression',\n        'match_expression'\n    ],\n    cognitiveNestedDecisionTypes: [\n        'if_expression',\n        'elif_expression',\n        'for_expression',\n        'while_expression',\n        'try_expression',\n        'match_expression'\n    ],\n    nestingControlTypes: [\n        'if_expression',\n        'elif_expression',\n        'for_expression',\n        'while_expression',\n        'try_expression',\n        'match_expression'\n    ],\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    // F#'s named-argument syntax is optional at the call site, so it doesn't prevent a\n    // future positional call — not a valid swap-risk mitigation. See language.ts's field doc.\n    keywordOnlyBoundaryTypes: [],\n    distinctTypeAdvice: 'a single-case union type',\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 ? rawRight.children[0] : 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    // F# indexes via `.[i]` rather than a dedicated subscript node — left unmodeled rather\n    // than guessed at with a fragile node-type match.\n    subscriptNodeTypes: [],\n    // F# also has interpolated ($\"...\") strings, but they aren't distinguished from plain\n    // strings here — a known gap, same tradeoff as leaving callNodeTypes unmodeled above.\n    isFormattedOrInterpolatedString(): boolean {\n        return false;\n    },\n    isDefaultParameterValue(): boolean {\n        return false;\n    },\n    // A bool literal parses as a `const` node wrapping a `bool` child (its .text is\n    // already \"true\"/\"false\", same as Python/TS's dedicated literal node types).\n    isBooleanLiteral(node: any): boolean {\n        return node?.type === 'const' && node.children?.length === 1 && node.children[0]?.type === 'bool';\n    },\n    // F# has no dedicated call-expression or argument-list node — curried application\n    // (`f true`) and paren-tuple application (`f(true, x)`) both parse as\n    // application_expression, and named-argument syntax (`retries = true`) reuses the\n    // same infix_expression node the primitive-obsession detector treats as equality\n    // elsewhere in this grammar. Three shapes count as \"positional\":\n    //   1. curried: `application_expression(callee, true)` — the literal is the\n    //      argument (not callee) child of an application_expression directly.\n    //   2. paren, single arg: `f(true)` — same shape as (1), the parens contribute no\n    //      extra node.\n    //   3. paren, multiple args: `f(true, x)` — the literal is a direct element of a\n    //      `tuple_expression` that is itself an application_expression's argument.\n    // A named argument's literal sits one level deeper, inside `infix_expression`\n    // (case 1/2's `application_expression` child, or case 3's `tuple_expression`\n    // element) — never a direct child of either, so it never matches below without a\n    // separate \"is labeled\" check.\n    isPositionalCallArgument(node: any): boolean {\n        const parent = node?.parent;\n        if (parent?.type === 'application_expression') {\n            // Guard against the literal being the callee itself — never true in\n            // practice (a bool can't be applied to arguments), kept for safety.\n            return parent.children?.[0]?.id !== node.id;\n        }\n        return parent?.type === 'tuple_expression' && parent.parent?.type === 'application_expression';\n    },\n    // F# has no compile-time-constant marker distinct from an ordinary `let` binding —\n    // module-scope binding is the only signal here.\n    isExplicitConstant(): boolean {\n        return false;\n    }\n};\n","import { LanguageAdapter } from '../core/language';\nimport { PYTHON } from './python';\nimport { FSHARP } from './fsharp';\nimport { TYPESCRIPT } from './typescript';\nimport { KOTLIN } from './kotlin';\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    kotlin: KOTLIN\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    '.kt': 'kotlin',\n    '.kts': 'kotlin'\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","import { LanguageAdapter } from '../core/language';\n\n// tree-sitter-kotlin (tree-sitter-grammars/tree-sitter-kotlin, v1.1.0) has a real\n// block wrapper like Python/TS, but its `else` is a bare keyword token with no\n// wrapper node at all: an `else if` chain's next `if_expression` is a direct\n// child of the previous one, not nested inside an else_clause (TS) nor a flat\n// elif sibling (Python/F#). See the ADC in matchOpportunity.ts's\n// collectChainBranches and inversion.ts's hasElse check for how that third shape\n// is handled — this adapter alone (elseClause: null, getElseIfBranches: []) is\n// not sufficient for those two detectors, unlike every other adapter.\nexport const KOTLIN: LanguageAdapter = {\n    id: 'kotlin',\n    grammarPath: 'grammars/tree-sitter-kotlin.wasm',\n    nodeTypes: {\n        block: 'block',\n        parameters: 'function_value_parameters',\n        ifStatement: 'if_expression',\n        elseClause: null,\n        forStatement: 'for_statement',\n        whileStatement: 'while_statement',\n        // if_expression already covers ternary-style use (Kotlin has no separate ternary node)\n        conditionalExpression: null,\n        lambda: 'lambda_literal',\n        importStatement: 'import',\n        importFromStatement: null,\n        expressionStatement: null,\n        // decision: 'property_declaration' (val/var NAME = value), not 'assignment' (bare\n        // reassignment `x = 5`, no val/var) — the only consumer (magicNumber.ts's\n        // isInConstantContext) wants \"is this literal the value of a named declaration\", which\n        // is what Python's `assignment`/TS's `lexical_declaration` mean there too\n        assignment: 'property_declaration',\n        module: 'source_file',\n        exportStatement: null,\n        // grammar splits line_comment/block_comment; this single-string field can only\n        // name one — block comments are a minor documented gap (inversion.ts's statement\n        // filter is the only consumer, and only for a comment as literally the first line)\n        comment: 'line_comment',\n        integerLiteral: 'number_literal',\n        floatLiteral: 'float_literal',\n        stringLiteral: 'string_literal'\n    },\n    isFunctionDefinition(node: any): boolean {\n        return node?.type === 'function_declaration';\n    },\n    parameterChildTypes: ['parameter'],\n    decisionNodeTypes: ['if_expression', 'for_statement', 'while_statement', 'when_expression', 'catch_block'],\n    cognitiveNestedDecisionTypes: [\n        'if_expression',\n        'for_statement',\n        'while_statement',\n        'when_expression',\n        'catch_block'\n    ],\n    nestingControlTypes: ['if_expression', 'for_statement', 'while_statement', 'try_expression'],\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 === 'block';\n    },\n    // Kotlin's try/catch has no else-branch construct.\n    isTryElseClause(): boolean {\n        return false;\n    },\n    variableReferenceNodeTypes: ['identifier', 'navigation_expression'],\n    extractTypedParameter(node: any): { name: string; type: string } | null {\n        if (node?.type !== '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 === 'user_type');\n        if (!nameNode || !typeNode) {\n            return null;\n        }\n        const typeIdentifier = typeNode.children?.find((c: any) => c.type === 'identifier');\n        if (!typeIdentifier) {\n            return null;\n        }\n        return { name: nameNode.text, type: typeIdentifier.text };\n    },\n    primitiveTypeNames: new Set(['Int', 'Long', 'Short', 'Byte', 'Double', 'Float', 'Boolean', 'String', 'Char']),\n    // Kotlin has no enforced-keyword-only parameter syntax (named arguments are optional\n    // at the call site) — see language.ts's field doc, same reasoning as F#.\n    keywordOnlyBoundaryTypes: [],\n    // decision: only suggests value class, not typealias — a typealias is just a synonym (the\n    // compiler still sees the underlying primitive), so it wouldn't actually catch the swap this\n    // warning is about, unlike Python's NewType/TS's branded type/F#'s single-case union, which\n    // this field's other adapters correctly point to\n    distinctTypeAdvice: 'a value class (@JvmInline value class)',\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    // Kotlin's set-membership idiom (`x in listOf(...)`) is an in_expression whose right side\n    // is normally a call_expression, not a literal collection — not modeled here, same\n    // precedent as typescript.ts. Repeated equality checks still accumulate via\n    // getEqualityComparisons.\n    getMembershipComparisons(): Array<{ left: any; values: string[] }> {\n        return [];\n    },\n    // No flat elif node exists — Kotlin's chain is walked via the bare-nested-if fallback in\n    // matchOpportunity.ts's collectChainBranches instead.\n    getElseIfBranches(): any[] {\n        return [];\n    },\n    subscriptNodeTypes: ['index_expression'],\n    isFormattedOrInterpolatedString(node: any): boolean {\n        return node?.children?.some((c: any) => c.type === 'interpolation') ?? false;\n    },\n    isDefaultParameterValue(node: any): boolean {\n        // decision: compares node identity by `.id`, not `===` — see the matching comment in\n        // python.ts's isFormattedOrInterpolatedString for why\n        // decision: a default value isn't nested inside the `parameter` node itself —\n        // function_value_parameters is a flat seq(parameter_modifiers?, parameter, ('=' expr)?),\n        // so the default value's siblings (not ancestors) are the '=' token and the parameter\n        const parent = node?.parent;\n        if (parent?.type !== 'function_value_parameters') {\n            return false;\n        }\n        const siblings = parent.children ?? [];\n        const index = siblings.findIndex((c: any) => c.id === node.id);\n        return index >= 2 && siblings[index - 1]?.type === '=' && siblings[index - 2]?.type === 'parameter';\n    },\n    // decision: true/false have no dedicated literal node in this grammar — they lex as plain\n    // `identifier` tokens (verified: no boolean_literal rule exists). Safe to key off text since\n    // true/false are hard keywords in Kotlin, not shadowable identifiers.\n    isBooleanLiteral(node: any): boolean {\n        return node?.type === 'identifier' && (node.text === 'true' || node.text === 'false');\n    },\n    // decision: every call argument (named or positional) wraps in `value_argument`, so unlike\n    // the other adapters' direct-parent check, this also has to rule out a named argument\n    // (`retries = true`) by checking the literal is value_argument's *first* child — a named\n    // argument's value_argument instead starts with `identifier '='` before the value.\n    isPositionalCallArgument(node: any): boolean {\n        const valueArgument = node?.parent;\n        if (valueArgument?.type !== 'value_argument' || valueArgument.parent?.type !== 'value_arguments') {\n            return false;\n        }\n        if (valueArgument.parent.parent?.type !== 'call_expression') {\n            return false;\n        }\n        return valueArgument.children?.[0]?.id === node.id;\n    },\n    // decision: `const val` is an explicit, compiler-enforced compile-time-constant marker —\n    // unlike the module-scope heuristic isInConstantContext (magicNumber.ts) otherwise relies\n    // on, this is valid at ANY nesting depth (a companion object's `const val` is just as much\n    // a real constant as a top-level one), so it's checked as its own signal rather than folded\n    // into that scope walk.\n    isExplicitConstant(node: any): boolean {\n        if (node?.type !== 'property_declaration') {\n            return false;\n        }\n        const modifiers = node.children?.find((c: any) => c.type === 'modifiers');\n        return (\n            modifiers?.children?.some(\n                (modifier: any) =>\n                    modifier.type === 'property_modifier' && modifier.children?.some((c: any) => c.type === 'const')\n            ) ?? false\n        );\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',\n        'elif_clause',\n        'while_statement',\n        'for_statement',\n        'except_clause',\n        'conditional_expression',\n        'match_statement'\n    ],\n    cognitiveNestedDecisionTypes: [\n        'if_statement',\n        'elif_clause',\n        'for_statement',\n        'while_statement',\n        'except_clause',\n        'match_statement'\n    ],\n    nestingControlTypes: [\n        'if_statement',\n        'for_statement',\n        'while_statement',\n        'with_statement',\n        'try_statement',\n        'match_statement'\n    ],\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    keywordOnlyBoundaryTypes: ['keyword_separator', 'list_splat_pattern'],\n    distinctTypeAdvice: 'NewType or a dataclass',\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    subscriptNodeTypes: ['subscript'],\n    isFormattedOrInterpolatedString(node: any): boolean {\n        if (node?.children?.some((c: any) => c.type === 'interpolation')) {\n            // f-string\n            return true;\n        }\n        // decision: compares node identity by `.id`, not `===` — web-tree-sitter mints a fresh\n        // JS wrapper object on every `.children`/`.parent` access, so two accessors that reach\n        // the same underlying tree node are not reference-equal even though `.id` matches\n        const parent = node?.parent;\n        if (\n            parent?.type === 'binary_operator' &&\n            parent.children?.[0]?.id === node.id &&\n            parent.children?.some((c: any) => c.type === '%')\n        ) {\n            // \"%s\" % value\n            return true;\n        }\n        if (parent?.type === 'attribute' && parent.children?.[0]?.id === node.id) {\n            const methodName = parent.children?.find((c: any) => c.type === 'identifier');\n            if (methodName?.text === 'format' && parent.parent?.type === 'call') {\n                return true;\n            }\n        }\n        return false;\n    },\n    isDefaultParameterValue(node: any): boolean {\n        const parent = node?.parent;\n        return (\n            (parent?.type === 'default_parameter' || parent?.type === 'typed_default_parameter') &&\n            parent.children?.[parent.children.length - 1]?.id === node.id\n        );\n    },\n    isBooleanLiteral(node: any): boolean {\n        return node?.type === 'true' || node?.type === 'false';\n    },\n    // A keyword argument (`retries=True`) wraps the literal in its own `keyword_argument`\n    // node, so a labeled boolean's parent is never `argument_list` directly.\n    isPositionalCallArgument(node: any): boolean {\n        return node?.parent?.type === 'argument_list' && node.parent.parent?.type === 'call';\n    },\n    // Python has no dedicated compile-time-constant marker — module-scope assignment is the\n    // only signal (see isInConstantContext in magicNumber.ts).\n    isExplicitConstant(): boolean {\n        return false;\n    }\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',\n        'for_statement',\n        'for_in_statement',\n        'while_statement',\n        'catch_clause',\n        'ternary_expression'\n    ],\n    cognitiveNestedDecisionTypes: [\n        'if_statement',\n        'for_statement',\n        'for_in_statement',\n        'while_statement',\n        'catch_clause'\n    ],\n    nestingControlTypes: ['if_statement', 'for_statement', 'for_in_statement', 'while_statement', 'try_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    // TS has no enforced-keyword-only parameter syntax — see language.ts's field doc.\n    keywordOnlyBoundaryTypes: [],\n    distinctTypeAdvice: 'a branded/nominal type (e.g. a tagged type alias)',\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    subscriptNodeTypes: ['subscript_expression'],\n    // TS has no node type where an interpolated/formatted string still shares\n    // stringLiteral's node type — template literals parse as `template_string`,\n    // which the traversal never visits as a string literal in the first place.\n    isFormattedOrInterpolatedString(): boolean {\n        return false;\n    },\n    isDefaultParameterValue(node: any): boolean {\n        // decision: compares node identity by `.id`, not `===` — see the matching comment in\n        // python.ts's isFormattedOrInterpolatedString for why\n        // decision: a parameter with a default value (`x: number = 1`) still parses as\n        // `required_parameter`, not `optional_parameter` (that node type is reserved for `x?:\n        // number`) — so this checks for the `=` child rather than trusting the parameter's own\n        // node type to signal \"has a default\"\n        const parent = node?.parent;\n        if (parent?.type !== 'required_parameter' && parent?.type !== 'optional_parameter') {\n            return false;\n        }\n        return (\n            parent.children?.some((c: any) => c.type === '=') &&\n            parent.children?.[parent.children.length - 1]?.id === node.id\n        );\n    },\n    isBooleanLiteral(node: any): boolean {\n        return node?.type === 'true' || node?.type === 'false';\n    },\n    // An object-literal field (`{ retries: true }`) wraps the literal in `pair` inside\n    // `object`, so a labeled boolean's parent is never `arguments` directly.\n    isPositionalCallArgument(node: any): boolean {\n        return node?.parent?.type === 'arguments' && node.parent.parent?.type === 'call_expression';\n    },\n    // TS's `const` is block-scoping, not a compile-time-constant marker (unlike Kotlin's\n    // `const val`) — module-scope lexical_declaration is the only signal here.\n    isExplicitConstant(): boolean {\n        return false;\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    OPAQUE_BOOLEAN: 'opaque-boolean' as const,\n    SUPPRESSION: 'suppression' 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:\n        | 'nesting'\n        | 'complexity'\n        | 'cognitive'\n        | 'naming'\n        | 'coherence'\n        | 'magic'\n        | 'parameters'\n        | 'inversion'\n        | 'primitive-obsession'\n        | 'match-opportunity'\n        | 'logical-control-flow'\n        | 'opaque-boolean'\n        | 'suppression';\n    severity: 'low' | 'medium' | 'high';\n    message: string;\n    hotspots?: ComplexityHotspot[];\n}\n","module.exports = require(\"child_process\");","module.exports = require(\"fs\");","module.exports = require(\"fs/promises\");","module.exports = require(\"path\");","\"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/web-tree-sitter.cjs\nvar require_web_tree_sitter = __commonJS({\n  \"lib/web-tree-sitter.cjs\"(exports, module) {\n    \"use strict\";\n    var Module = (() => {\n      var _scriptName = typeof document != \"undefined\" ? document.currentScript?.src : void 0;\n      return async function(moduleArg = {}) {\n        var moduleRtn;\n        var Module = moduleArg;\n        var ENVIRONMENT_IS_WEB = typeof window == \"object\";\n        var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != \"undefined\";\n        var ENVIRONMENT_IS_NODE = typeof process == \"object\" && process.versions?.node && process.type != \"renderer\";\n        Module.currentQueryProgressCallback = null;\n        Module.currentProgressCallback = null;\n        Module.currentLogCallback = null;\n        Module.currentParseCallback = null;\n        var arguments_ = [];\n        var thisProgram = \"./this.program\";\n        var quit_ = /* @__PURE__ */ __name((status, toThrow) => {\n          throw toThrow;\n        }, \"quit_\");\n        if (typeof __filename != \"undefined\") {\n          _scriptName = __filename;\n        } else if (ENVIRONMENT_IS_WORKER) {\n          _scriptName = self.location.href;\n        }\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          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 (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          try {\n            scriptDirectory = new URL(\".\", _scriptName).href;\n          } catch {\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 = console.log.bind(console);\n        var err = console.error.bind(console);\n        var dynamicLibraries = [];\n        var wasmBinary;\n        var ABORT = false;\n        var EXITSTATUS;\n        var isFileURI = /* @__PURE__ */ __name((filename) => filename.startsWith(\"file://\"), \"isFileURI\");\n        var readyPromiseResolve, readyPromiseReject;\n        var wasmMemory;\n        var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;\n        var HEAP64, HEAPU64;\n        var HEAP_DATA_VIEW;\n        var runtimeInitialized = false;\n        function updateMemoryViews() {\n          var b = wasmMemory.buffer;\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          Module[\"HEAP_DATA_VIEW\"] = HEAP_DATA_VIEW = new DataView(b);\n          LE_HEAP_UPDATE();\n        }\n        __name(updateMemoryViews, \"updateMemoryViews\");\n        function initMemory() {\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        }\n        __name(initMemory, \"initMemory\");\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        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(\"web-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 && !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            assignWasmExports(wasmExports);\n            return wasmExports;\n          }\n          __name(receiveInstance, \"receiveInstance\");\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                resolve(receiveInstance(mod, inst));\n              });\n            });\n          }\n          wasmBinaryFile ??= findWasmBinary();\n          var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info2);\n          var exports2 = receiveInstantiationResult(result);\n          return exports2;\n        }\n        __name(createWasm, \"createWasm\");\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_ATOMICS_NATIVE_BYTE_ORDER = [];\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_I64 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getBigInt64(byteOffset, true), \"LE_HEAP_LOAD_I64\");\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_I64 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setBigInt64(byteOffset, value, true), \"LE_HEAP_STORE_I64\");\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.push(cb), \"addOnPostRun\");\n        var onPreRuns = [];\n        var addOnPreRun = /* @__PURE__ */ __name((cb) => onPreRuns.push(cb), \"addOnPreRun\");\n        var UTF8Decoder = typeof TextDecoder != \"undefined\" ? new TextDecoder() : void 0;\n        var findStringEnd = /* @__PURE__ */ __name((heapOrArray, idx, maxBytesToRead, ignoreNul) => {\n          var maxIdx = idx + maxBytesToRead;\n          if (ignoreNul) return maxIdx;\n          while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;\n          return idx;\n        }, \"findStringEnd\");\n        var UTF8ArrayToString = /* @__PURE__ */ __name((heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {\n          var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);\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 getStringList() {\n            var count2 = getLEB();\n            var rtn = [];\n            while (count2--) rtn.push(getString());\n            return rtn;\n          }\n          __name(getStringList, \"getStringList\");\n          function failIf(condition, message) {\n            if (condition) throw new Error(message);\n          }\n          __name(failIf, \"failIf\");\n          if (binary2 instanceof WebAssembly.Module) {\n            var dylinkSection = WebAssembly.Module.customSections(binary2, \"dylink.0\");\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            var name2 = getString();\n            failIf(name2 !== \"dylink.0\");\n          }\n          var customSection = {\n            neededDynlibs: [],\n            tlsExports: /* @__PURE__ */ new Set(),\n            weakImports: /* @__PURE__ */ new Set(),\n            runtimePaths: []\n          };\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_DYLINK_RUNTIME_PATH = 5;\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              customSection.neededDynlibs = getStringList();\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 if (subsectionType === WASM_DYLINK_RUNTIME_PATH) {\n              customSection.runtimePaths = getStringList();\n            } else {\n              offset += subsectionSize;\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 LE_HEAP_LOAD_I64((ptr >> 3) * 8);\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 = 78240;\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 uleb128EncodeWithLen = /* @__PURE__ */ __name((arr) => {\n          const n = arr.length;\n          return [n % 128 | 128, n >> 7, ...arr];\n        }, \"uleb128EncodeWithLen\");\n        var wasmTypeCodes = {\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        var generateTypePack = /* @__PURE__ */ __name((types) => uleb128EncodeWithLen(Array.from(types, (type) => {\n          var code = wasmTypeCodes[type];\n          return code;\n        })), \"generateTypePack\");\n        var convertJsFunctionToWasm = /* @__PURE__ */ __name((func2, sig) => {\n          var bytes = Uint8Array.of(\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            ...uleb128EncodeWithLen([\n              1,\n              // count: 1\n              96,\n              // param types\n              ...generateTypePack(sig.slice(1)),\n              // return types (for now only supporting [] if `void` and single [T] otherwise)\n              ...generateTypePack(sig[0] === \"v\" ? \"\" : sig[0])\n            ]),\n            // The rest of the module is static\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(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            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          return wasmTable[\"grow\"](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 = [], promising = false) => {\n          var func2 = getWasmTableEntry(ptr);\n          var rtn = func2(...args2);\n          function convert(rtn2) {\n            return rtn2;\n          }\n          __name(convert, \"convert\");\n          return convert(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.push(cb), \"addOnPostCtor\");\n        var UTF8ToString = /* @__PURE__ */ __name((ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : \"\", \"UTF8ToString\");\n        var loadWebAssemblyModule = /* @__PURE__ */ __name((binary, flags, libName, localScope, handle) => {\n          var metadata = getDylinkMetadata(binary);\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            currentModuleWeakSymbols = metadata.weakImports;\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              return (async () => {\n                var instance2;\n                if (binary instanceof WebAssembly.Module) {\n                  instance2 = new WebAssembly.Instance(binary, info);\n                } else {\n                  ({ module: binary, instance: instance2 } = await WebAssembly.instantiate(binary, info));\n                }\n                return postInstantiation(binary, instance2);\n              })();\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          flags = {\n            ...flags,\n            rpath: {\n              parentLibPath: libName,\n              paths: metadata.runtimePaths\n            }\n          };\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 runDependencies = 0;\n        var dependenciesFulfilled = null;\n        var removeRunDependency = /* @__PURE__ */ __name((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        }, \"removeRunDependency\");\n        var addRunDependency = /* @__PURE__ */ __name((id) => {\n          runDependencies++;\n          Module[\"monitorRunDependencies\"]?.(runDependencies);\n        }, \"addRunDependency\");\n        var loadDylibs = /* @__PURE__ */ __name(async () => {\n          if (!dynamicLibraries.length) {\n            reportUndefinedSymbols();\n            return;\n          }\n          addRunDependency(\"loadDylibs\");\n          for (var lib of dynamicLibraries) {\n            await loadDynamicLibrary(lib, {\n              loadAsync: true,\n              global: true,\n              nodelete: true,\n              allowUndefined: true\n            });\n          }\n          reportUndefinedSymbols();\n          removeRunDependency(\"loadDylibs\");\n        }, \"loadDylibs\");\n        var 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              LE_HEAP_STORE_I64((ptr >> 3) * 8, 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_high = 78240;\n        var ___stack_low = 12704;\n        var ___stack_pointer = new WebAssembly.Global({\n          \"value\": \"i32\",\n          \"mutable\": true\n        }, 78240);\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 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 oldHeapSize = wasmMemory.buffer.byteLength;\n          var pages = (size - oldHeapSize + 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        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 _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 _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.codePointAt(i2);\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              i2++;\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        LE_ATOMICS_NATIVE_BYTE_ORDER = new Int8Array(new Int16Array([1]).buffer)[0] === 1 ? [\n          /* little endian */\n          ((x) => x),\n          ((x) => x),\n          void 0,\n          ((x) => x)\n        ] : [\n          /* big endian */\n          ((x) => x),\n          ((x) => ((x & 65280) << 8 | (x & 255) << 24) >> 16),\n          void 0,\n          ((x) => x >> 24 & 255 | x >> 8 & 65280 | (x & 65280) << 8 | (x & 255) << 24)\n        ];\n        function LE_HEAP_UPDATE() {\n          HEAPU16.unsigned = ((x) => x & 65535);\n          HEAPU32.unsigned = ((x) => x >>> 0);\n        }\n        __name(LE_HEAP_UPDATE, \"LE_HEAP_UPDATE\");\n        {\n          initMemory();\n          if (Module[\"noExitRuntime\"]) noExitRuntime = Module[\"noExitRuntime\"];\n          if (Module[\"print\"]) out = Module[\"print\"];\n          if (Module[\"printErr\"]) err = Module[\"printErr\"];\n          if (Module[\"dynamicLibraries\"]) dynamicLibraries = Module[\"dynamicLibraries\"];\n          if (Module[\"wasmBinary\"]) wasmBinary = Module[\"wasmBinary\"];\n          if (Module[\"arguments\"]) arguments_ = Module[\"arguments\"];\n          if (Module[\"thisProgram\"]) thisProgram = Module[\"thisProgram\"];\n          if (Module[\"preInit\"]) {\n            if (typeof Module[\"preInit\"] == \"function\") Module[\"preInit\"] = [Module[\"preInit\"]];\n            while (Module[\"preInit\"].length > 0) {\n              Module[\"preInit\"].shift()();\n            }\n          }\n        }\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        Module[\"LE_HEAP_STORE_I64\"] = LE_HEAP_STORE_I64;\n        var ASM_CONSTS = {};\n        var _malloc, _calloc, _realloc, _free, _ts_range_edit, _memcmp, _ts_language_symbol_count, _ts_language_state_count, _ts_language_abi_version, _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_point_edit, _ts_parser_delete, _ts_parser_reset, _ts_parser_set_language, _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_metadata_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, _setThrew, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, ___wasm_apply_data_relocs;\n        function assignWasmExports(wasmExports2) {\n          Module[\"_malloc\"] = _malloc = wasmExports2[\"malloc\"];\n          Module[\"_calloc\"] = _calloc = wasmExports2[\"calloc\"];\n          Module[\"_realloc\"] = _realloc = wasmExports2[\"realloc\"];\n          Module[\"_free\"] = _free = wasmExports2[\"free\"];\n          Module[\"_ts_range_edit\"] = _ts_range_edit = wasmExports2[\"ts_range_edit\"];\n          Module[\"_memcmp\"] = _memcmp = wasmExports2[\"memcmp\"];\n          Module[\"_ts_language_symbol_count\"] = _ts_language_symbol_count = wasmExports2[\"ts_language_symbol_count\"];\n          Module[\"_ts_language_state_count\"] = _ts_language_state_count = wasmExports2[\"ts_language_state_count\"];\n          Module[\"_ts_language_abi_version\"] = _ts_language_abi_version = wasmExports2[\"ts_language_abi_version\"];\n          Module[\"_ts_language_name\"] = _ts_language_name = wasmExports2[\"ts_language_name\"];\n          Module[\"_ts_language_field_count\"] = _ts_language_field_count = wasmExports2[\"ts_language_field_count\"];\n          Module[\"_ts_language_next_state\"] = _ts_language_next_state = wasmExports2[\"ts_language_next_state\"];\n          Module[\"_ts_language_symbol_name\"] = _ts_language_symbol_name = wasmExports2[\"ts_language_symbol_name\"];\n          Module[\"_ts_language_symbol_for_name\"] = _ts_language_symbol_for_name = wasmExports2[\"ts_language_symbol_for_name\"];\n          Module[\"_strncmp\"] = _strncmp = wasmExports2[\"strncmp\"];\n          Module[\"_ts_language_symbol_type\"] = _ts_language_symbol_type = wasmExports2[\"ts_language_symbol_type\"];\n          Module[\"_ts_language_field_name_for_id\"] = _ts_language_field_name_for_id = wasmExports2[\"ts_language_field_name_for_id\"];\n          Module[\"_ts_lookahead_iterator_new\"] = _ts_lookahead_iterator_new = wasmExports2[\"ts_lookahead_iterator_new\"];\n          Module[\"_ts_lookahead_iterator_delete\"] = _ts_lookahead_iterator_delete = wasmExports2[\"ts_lookahead_iterator_delete\"];\n          Module[\"_ts_lookahead_iterator_reset_state\"] = _ts_lookahead_iterator_reset_state = wasmExports2[\"ts_lookahead_iterator_reset_state\"];\n          Module[\"_ts_lookahead_iterator_reset\"] = _ts_lookahead_iterator_reset = wasmExports2[\"ts_lookahead_iterator_reset\"];\n          Module[\"_ts_lookahead_iterator_next\"] = _ts_lookahead_iterator_next = wasmExports2[\"ts_lookahead_iterator_next\"];\n          Module[\"_ts_lookahead_iterator_current_symbol\"] = _ts_lookahead_iterator_current_symbol = wasmExports2[\"ts_lookahead_iterator_current_symbol\"];\n          Module[\"_ts_point_edit\"] = _ts_point_edit = wasmExports2[\"ts_point_edit\"];\n          Module[\"_ts_parser_delete\"] = _ts_parser_delete = wasmExports2[\"ts_parser_delete\"];\n          Module[\"_ts_parser_reset\"] = _ts_parser_reset = wasmExports2[\"ts_parser_reset\"];\n          Module[\"_ts_parser_set_language\"] = _ts_parser_set_language = wasmExports2[\"ts_parser_set_language\"];\n          Module[\"_ts_parser_set_included_ranges\"] = _ts_parser_set_included_ranges = wasmExports2[\"ts_parser_set_included_ranges\"];\n          Module[\"_ts_query_new\"] = _ts_query_new = wasmExports2[\"ts_query_new\"];\n          Module[\"_ts_query_delete\"] = _ts_query_delete = wasmExports2[\"ts_query_delete\"];\n          Module[\"_iswspace\"] = _iswspace = wasmExports2[\"iswspace\"];\n          Module[\"_iswalnum\"] = _iswalnum = wasmExports2[\"iswalnum\"];\n          Module[\"_ts_query_pattern_count\"] = _ts_query_pattern_count = wasmExports2[\"ts_query_pattern_count\"];\n          Module[\"_ts_query_capture_count\"] = _ts_query_capture_count = wasmExports2[\"ts_query_capture_count\"];\n          Module[\"_ts_query_string_count\"] = _ts_query_string_count = wasmExports2[\"ts_query_string_count\"];\n          Module[\"_ts_query_capture_name_for_id\"] = _ts_query_capture_name_for_id = wasmExports2[\"ts_query_capture_name_for_id\"];\n          Module[\"_ts_query_capture_quantifier_for_id\"] = _ts_query_capture_quantifier_for_id = wasmExports2[\"ts_query_capture_quantifier_for_id\"];\n          Module[\"_ts_query_string_value_for_id\"] = _ts_query_string_value_for_id = wasmExports2[\"ts_query_string_value_for_id\"];\n          Module[\"_ts_query_predicates_for_pattern\"] = _ts_query_predicates_for_pattern = wasmExports2[\"ts_query_predicates_for_pattern\"];\n          Module[\"_ts_query_start_byte_for_pattern\"] = _ts_query_start_byte_for_pattern = wasmExports2[\"ts_query_start_byte_for_pattern\"];\n          Module[\"_ts_query_end_byte_for_pattern\"] = _ts_query_end_byte_for_pattern = wasmExports2[\"ts_query_end_byte_for_pattern\"];\n          Module[\"_ts_query_is_pattern_rooted\"] = _ts_query_is_pattern_rooted = wasmExports2[\"ts_query_is_pattern_rooted\"];\n          Module[\"_ts_query_is_pattern_non_local\"] = _ts_query_is_pattern_non_local = wasmExports2[\"ts_query_is_pattern_non_local\"];\n          Module[\"_ts_query_is_pattern_guaranteed_at_step\"] = _ts_query_is_pattern_guaranteed_at_step = wasmExports2[\"ts_query_is_pattern_guaranteed_at_step\"];\n          Module[\"_ts_query_disable_capture\"] = _ts_query_disable_capture = wasmExports2[\"ts_query_disable_capture\"];\n          Module[\"_ts_query_disable_pattern\"] = _ts_query_disable_pattern = wasmExports2[\"ts_query_disable_pattern\"];\n          Module[\"_ts_tree_copy\"] = _ts_tree_copy = wasmExports2[\"ts_tree_copy\"];\n          Module[\"_ts_tree_delete\"] = _ts_tree_delete = wasmExports2[\"ts_tree_delete\"];\n          Module[\"_ts_init\"] = _ts_init = wasmExports2[\"ts_init\"];\n          Module[\"_ts_parser_new_wasm\"] = _ts_parser_new_wasm = wasmExports2[\"ts_parser_new_wasm\"];\n          Module[\"_ts_parser_enable_logger_wasm\"] = _ts_parser_enable_logger_wasm = wasmExports2[\"ts_parser_enable_logger_wasm\"];\n          Module[\"_ts_parser_parse_wasm\"] = _ts_parser_parse_wasm = wasmExports2[\"ts_parser_parse_wasm\"];\n          Module[\"_ts_parser_included_ranges_wasm\"] = _ts_parser_included_ranges_wasm = wasmExports2[\"ts_parser_included_ranges_wasm\"];\n          Module[\"_ts_language_type_is_named_wasm\"] = _ts_language_type_is_named_wasm = wasmExports2[\"ts_language_type_is_named_wasm\"];\n          Module[\"_ts_language_type_is_visible_wasm\"] = _ts_language_type_is_visible_wasm = wasmExports2[\"ts_language_type_is_visible_wasm\"];\n          Module[\"_ts_language_metadata_wasm\"] = _ts_language_metadata_wasm = wasmExports2[\"ts_language_metadata_wasm\"];\n          Module[\"_ts_language_supertypes_wasm\"] = _ts_language_supertypes_wasm = wasmExports2[\"ts_language_supertypes_wasm\"];\n          Module[\"_ts_language_subtypes_wasm\"] = _ts_language_subtypes_wasm = wasmExports2[\"ts_language_subtypes_wasm\"];\n          Module[\"_ts_tree_root_node_wasm\"] = _ts_tree_root_node_wasm = wasmExports2[\"ts_tree_root_node_wasm\"];\n          Module[\"_ts_tree_root_node_with_offset_wasm\"] = _ts_tree_root_node_with_offset_wasm = wasmExports2[\"ts_tree_root_node_with_offset_wasm\"];\n          Module[\"_ts_tree_edit_wasm\"] = _ts_tree_edit_wasm = wasmExports2[\"ts_tree_edit_wasm\"];\n          Module[\"_ts_tree_included_ranges_wasm\"] = _ts_tree_included_ranges_wasm = wasmExports2[\"ts_tree_included_ranges_wasm\"];\n          Module[\"_ts_tree_get_changed_ranges_wasm\"] = _ts_tree_get_changed_ranges_wasm = wasmExports2[\"ts_tree_get_changed_ranges_wasm\"];\n          Module[\"_ts_tree_cursor_new_wasm\"] = _ts_tree_cursor_new_wasm = wasmExports2[\"ts_tree_cursor_new_wasm\"];\n          Module[\"_ts_tree_cursor_copy_wasm\"] = _ts_tree_cursor_copy_wasm = wasmExports2[\"ts_tree_cursor_copy_wasm\"];\n          Module[\"_ts_tree_cursor_delete_wasm\"] = _ts_tree_cursor_delete_wasm = wasmExports2[\"ts_tree_cursor_delete_wasm\"];\n          Module[\"_ts_tree_cursor_reset_wasm\"] = _ts_tree_cursor_reset_wasm = wasmExports2[\"ts_tree_cursor_reset_wasm\"];\n          Module[\"_ts_tree_cursor_reset_to_wasm\"] = _ts_tree_cursor_reset_to_wasm = wasmExports2[\"ts_tree_cursor_reset_to_wasm\"];\n          Module[\"_ts_tree_cursor_goto_first_child_wasm\"] = _ts_tree_cursor_goto_first_child_wasm = wasmExports2[\"ts_tree_cursor_goto_first_child_wasm\"];\n          Module[\"_ts_tree_cursor_goto_last_child_wasm\"] = _ts_tree_cursor_goto_last_child_wasm = wasmExports2[\"ts_tree_cursor_goto_last_child_wasm\"];\n          Module[\"_ts_tree_cursor_goto_first_child_for_index_wasm\"] = _ts_tree_cursor_goto_first_child_for_index_wasm = wasmExports2[\"ts_tree_cursor_goto_first_child_for_index_wasm\"];\n          Module[\"_ts_tree_cursor_goto_first_child_for_position_wasm\"] = _ts_tree_cursor_goto_first_child_for_position_wasm = wasmExports2[\"ts_tree_cursor_goto_first_child_for_position_wasm\"];\n          Module[\"_ts_tree_cursor_goto_next_sibling_wasm\"] = _ts_tree_cursor_goto_next_sibling_wasm = wasmExports2[\"ts_tree_cursor_goto_next_sibling_wasm\"];\n          Module[\"_ts_tree_cursor_goto_previous_sibling_wasm\"] = _ts_tree_cursor_goto_previous_sibling_wasm = wasmExports2[\"ts_tree_cursor_goto_previous_sibling_wasm\"];\n          Module[\"_ts_tree_cursor_goto_descendant_wasm\"] = _ts_tree_cursor_goto_descendant_wasm = wasmExports2[\"ts_tree_cursor_goto_descendant_wasm\"];\n          Module[\"_ts_tree_cursor_goto_parent_wasm\"] = _ts_tree_cursor_goto_parent_wasm = wasmExports2[\"ts_tree_cursor_goto_parent_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_type_id_wasm\"] = _ts_tree_cursor_current_node_type_id_wasm = wasmExports2[\"ts_tree_cursor_current_node_type_id_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_state_id_wasm\"] = _ts_tree_cursor_current_node_state_id_wasm = wasmExports2[\"ts_tree_cursor_current_node_state_id_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_is_named_wasm\"] = _ts_tree_cursor_current_node_is_named_wasm = wasmExports2[\"ts_tree_cursor_current_node_is_named_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_is_missing_wasm\"] = _ts_tree_cursor_current_node_is_missing_wasm = wasmExports2[\"ts_tree_cursor_current_node_is_missing_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_id_wasm\"] = _ts_tree_cursor_current_node_id_wasm = wasmExports2[\"ts_tree_cursor_current_node_id_wasm\"];\n          Module[\"_ts_tree_cursor_start_position_wasm\"] = _ts_tree_cursor_start_position_wasm = wasmExports2[\"ts_tree_cursor_start_position_wasm\"];\n          Module[\"_ts_tree_cursor_end_position_wasm\"] = _ts_tree_cursor_end_position_wasm = wasmExports2[\"ts_tree_cursor_end_position_wasm\"];\n          Module[\"_ts_tree_cursor_start_index_wasm\"] = _ts_tree_cursor_start_index_wasm = wasmExports2[\"ts_tree_cursor_start_index_wasm\"];\n          Module[\"_ts_tree_cursor_end_index_wasm\"] = _ts_tree_cursor_end_index_wasm = wasmExports2[\"ts_tree_cursor_end_index_wasm\"];\n          Module[\"_ts_tree_cursor_current_field_id_wasm\"] = _ts_tree_cursor_current_field_id_wasm = wasmExports2[\"ts_tree_cursor_current_field_id_wasm\"];\n          Module[\"_ts_tree_cursor_current_depth_wasm\"] = _ts_tree_cursor_current_depth_wasm = wasmExports2[\"ts_tree_cursor_current_depth_wasm\"];\n          Module[\"_ts_tree_cursor_current_descendant_index_wasm\"] = _ts_tree_cursor_current_descendant_index_wasm = wasmExports2[\"ts_tree_cursor_current_descendant_index_wasm\"];\n          Module[\"_ts_tree_cursor_current_node_wasm\"] = _ts_tree_cursor_current_node_wasm = wasmExports2[\"ts_tree_cursor_current_node_wasm\"];\n          Module[\"_ts_node_symbol_wasm\"] = _ts_node_symbol_wasm = wasmExports2[\"ts_node_symbol_wasm\"];\n          Module[\"_ts_node_field_name_for_child_wasm\"] = _ts_node_field_name_for_child_wasm = wasmExports2[\"ts_node_field_name_for_child_wasm\"];\n          Module[\"_ts_node_field_name_for_named_child_wasm\"] = _ts_node_field_name_for_named_child_wasm = wasmExports2[\"ts_node_field_name_for_named_child_wasm\"];\n          Module[\"_ts_node_children_by_field_id_wasm\"] = _ts_node_children_by_field_id_wasm = wasmExports2[\"ts_node_children_by_field_id_wasm\"];\n          Module[\"_ts_node_first_child_for_byte_wasm\"] = _ts_node_first_child_for_byte_wasm = wasmExports2[\"ts_node_first_child_for_byte_wasm\"];\n          Module[\"_ts_node_first_named_child_for_byte_wasm\"] = _ts_node_first_named_child_for_byte_wasm = wasmExports2[\"ts_node_first_named_child_for_byte_wasm\"];\n          Module[\"_ts_node_grammar_symbol_wasm\"] = _ts_node_grammar_symbol_wasm = wasmExports2[\"ts_node_grammar_symbol_wasm\"];\n          Module[\"_ts_node_child_count_wasm\"] = _ts_node_child_count_wasm = wasmExports2[\"ts_node_child_count_wasm\"];\n          Module[\"_ts_node_named_child_count_wasm\"] = _ts_node_named_child_count_wasm = wasmExports2[\"ts_node_named_child_count_wasm\"];\n          Module[\"_ts_node_child_wasm\"] = _ts_node_child_wasm = wasmExports2[\"ts_node_child_wasm\"];\n          Module[\"_ts_node_named_child_wasm\"] = _ts_node_named_child_wasm = wasmExports2[\"ts_node_named_child_wasm\"];\n          Module[\"_ts_node_child_by_field_id_wasm\"] = _ts_node_child_by_field_id_wasm = wasmExports2[\"ts_node_child_by_field_id_wasm\"];\n          Module[\"_ts_node_next_sibling_wasm\"] = _ts_node_next_sibling_wasm = wasmExports2[\"ts_node_next_sibling_wasm\"];\n          Module[\"_ts_node_prev_sibling_wasm\"] = _ts_node_prev_sibling_wasm = wasmExports2[\"ts_node_prev_sibling_wasm\"];\n          Module[\"_ts_node_next_named_sibling_wasm\"] = _ts_node_next_named_sibling_wasm = wasmExports2[\"ts_node_next_named_sibling_wasm\"];\n          Module[\"_ts_node_prev_named_sibling_wasm\"] = _ts_node_prev_named_sibling_wasm = wasmExports2[\"ts_node_prev_named_sibling_wasm\"];\n          Module[\"_ts_node_descendant_count_wasm\"] = _ts_node_descendant_count_wasm = wasmExports2[\"ts_node_descendant_count_wasm\"];\n          Module[\"_ts_node_parent_wasm\"] = _ts_node_parent_wasm = wasmExports2[\"ts_node_parent_wasm\"];\n          Module[\"_ts_node_child_with_descendant_wasm\"] = _ts_node_child_with_descendant_wasm = wasmExports2[\"ts_node_child_with_descendant_wasm\"];\n          Module[\"_ts_node_descendant_for_index_wasm\"] = _ts_node_descendant_for_index_wasm = wasmExports2[\"ts_node_descendant_for_index_wasm\"];\n          Module[\"_ts_node_named_descendant_for_index_wasm\"] = _ts_node_named_descendant_for_index_wasm = wasmExports2[\"ts_node_named_descendant_for_index_wasm\"];\n          Module[\"_ts_node_descendant_for_position_wasm\"] = _ts_node_descendant_for_position_wasm = wasmExports2[\"ts_node_descendant_for_position_wasm\"];\n          Module[\"_ts_node_named_descendant_for_position_wasm\"] = _ts_node_named_descendant_for_position_wasm = wasmExports2[\"ts_node_named_descendant_for_position_wasm\"];\n          Module[\"_ts_node_start_point_wasm\"] = _ts_node_start_point_wasm = wasmExports2[\"ts_node_start_point_wasm\"];\n          Module[\"_ts_node_end_point_wasm\"] = _ts_node_end_point_wasm = wasmExports2[\"ts_node_end_point_wasm\"];\n          Module[\"_ts_node_start_index_wasm\"] = _ts_node_start_index_wasm = wasmExports2[\"ts_node_start_index_wasm\"];\n          Module[\"_ts_node_end_index_wasm\"] = _ts_node_end_index_wasm = wasmExports2[\"ts_node_end_index_wasm\"];\n          Module[\"_ts_node_to_string_wasm\"] = _ts_node_to_string_wasm = wasmExports2[\"ts_node_to_string_wasm\"];\n          Module[\"_ts_node_children_wasm\"] = _ts_node_children_wasm = wasmExports2[\"ts_node_children_wasm\"];\n          Module[\"_ts_node_named_children_wasm\"] = _ts_node_named_children_wasm = wasmExports2[\"ts_node_named_children_wasm\"];\n          Module[\"_ts_node_descendants_of_type_wasm\"] = _ts_node_descendants_of_type_wasm = wasmExports2[\"ts_node_descendants_of_type_wasm\"];\n          Module[\"_ts_node_is_named_wasm\"] = _ts_node_is_named_wasm = wasmExports2[\"ts_node_is_named_wasm\"];\n          Module[\"_ts_node_has_changes_wasm\"] = _ts_node_has_changes_wasm = wasmExports2[\"ts_node_has_changes_wasm\"];\n          Module[\"_ts_node_has_error_wasm\"] = _ts_node_has_error_wasm = wasmExports2[\"ts_node_has_error_wasm\"];\n          Module[\"_ts_node_is_error_wasm\"] = _ts_node_is_error_wasm = wasmExports2[\"ts_node_is_error_wasm\"];\n          Module[\"_ts_node_is_missing_wasm\"] = _ts_node_is_missing_wasm = wasmExports2[\"ts_node_is_missing_wasm\"];\n          Module[\"_ts_node_is_extra_wasm\"] = _ts_node_is_extra_wasm = wasmExports2[\"ts_node_is_extra_wasm\"];\n          Module[\"_ts_node_parse_state_wasm\"] = _ts_node_parse_state_wasm = wasmExports2[\"ts_node_parse_state_wasm\"];\n          Module[\"_ts_node_next_parse_state_wasm\"] = _ts_node_next_parse_state_wasm = wasmExports2[\"ts_node_next_parse_state_wasm\"];\n          Module[\"_ts_query_matches_wasm\"] = _ts_query_matches_wasm = wasmExports2[\"ts_query_matches_wasm\"];\n          Module[\"_ts_query_captures_wasm\"] = _ts_query_captures_wasm = wasmExports2[\"ts_query_captures_wasm\"];\n          Module[\"_memset\"] = _memset = wasmExports2[\"memset\"];\n          Module[\"_memcpy\"] = _memcpy = wasmExports2[\"memcpy\"];\n          Module[\"_memmove\"] = _memmove = wasmExports2[\"memmove\"];\n          Module[\"_iswalpha\"] = _iswalpha = wasmExports2[\"iswalpha\"];\n          Module[\"_iswblank\"] = _iswblank = wasmExports2[\"iswblank\"];\n          Module[\"_iswdigit\"] = _iswdigit = wasmExports2[\"iswdigit\"];\n          Module[\"_iswlower\"] = _iswlower = wasmExports2[\"iswlower\"];\n          Module[\"_iswupper\"] = _iswupper = wasmExports2[\"iswupper\"];\n          Module[\"_iswxdigit\"] = _iswxdigit = wasmExports2[\"iswxdigit\"];\n          Module[\"_memchr\"] = _memchr = wasmExports2[\"memchr\"];\n          Module[\"_strlen\"] = _strlen = wasmExports2[\"strlen\"];\n          Module[\"_strcmp\"] = _strcmp = wasmExports2[\"strcmp\"];\n          Module[\"_strncat\"] = _strncat = wasmExports2[\"strncat\"];\n          Module[\"_strncpy\"] = _strncpy = wasmExports2[\"strncpy\"];\n          Module[\"_towlower\"] = _towlower = wasmExports2[\"towlower\"];\n          Module[\"_towupper\"] = _towupper = wasmExports2[\"towupper\"];\n          _setThrew = wasmExports2[\"setThrew\"];\n          __emscripten_stack_restore = wasmExports2[\"_emscripten_stack_restore\"];\n          __emscripten_stack_alloc = wasmExports2[\"_emscripten_stack_alloc\"];\n          _emscripten_stack_get_current = wasmExports2[\"emscripten_stack_get_current\"];\n          ___wasm_apply_data_relocs = wasmExports2[\"__wasm_apply_data_relocs\"];\n        }\n        __name(assignWasmExports, \"assignWasmExports\");\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_high: ___stack_high,\n          /** @export */\n          __stack_low: ___stack_low,\n          /** @export */\n          __stack_pointer: ___stack_pointer,\n          /** @export */\n          __table_base: ___table_base,\n          /** @export */\n          _abort_js: __abort_js,\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        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\"] || false;\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        var wasmExports;\n        wasmExports = await createWasm();\n        run();\n        if (runtimeInitialized) {\n          moduleRtn = Module;\n        } else {\n          moduleRtn = new Promise((resolve, reject) => {\n            readyPromiseResolve = resolve;\n            readyPromiseReject = reject;\n          });\n        }\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  Edit: () => Edit,\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/edit.ts\nvar Edit = class {\n  static {\n    __name(this, \"Edit\");\n  }\n  /** The start position of the change. */\n  startPosition;\n  /** The end position of the change before the edit. */\n  oldEndPosition;\n  /** The end position of the change after the edit. */\n  newEndPosition;\n  /** The start index of the change. */\n  startIndex;\n  /** The end index of the change before the edit. */\n  oldEndIndex;\n  /** The end index of the change after the edit. */\n  newEndIndex;\n  constructor({\n    startIndex,\n    oldEndIndex,\n    newEndIndex,\n    startPosition,\n    oldEndPosition,\n    newEndPosition\n  }) {\n    this.startIndex = startIndex >>> 0;\n    this.oldEndIndex = oldEndIndex >>> 0;\n    this.newEndIndex = newEndIndex >>> 0;\n    this.startPosition = startPosition;\n    this.oldEndPosition = oldEndPosition;\n    this.newEndPosition = newEndPosition;\n  }\n  /**\n   * Edit a point and index to keep it in-sync with source code that has been edited.\n   *\n   * This function updates a single point's byte offset and row/column position\n   * based on an edit operation. This is useful for editing points without\n   * requiring a tree or node instance.\n   */\n  editPoint(point, index) {\n    let newIndex = index;\n    const newPoint = { ...point };\n    if (index >= this.oldEndIndex) {\n      newIndex = this.newEndIndex + (index - this.oldEndIndex);\n      const originalRow = point.row;\n      newPoint.row = this.newEndPosition.row + (point.row - this.oldEndPosition.row);\n      newPoint.column = originalRow === this.oldEndPosition.row ? this.newEndPosition.column + (point.column - this.oldEndPosition.column) : point.column;\n    } else if (index > this.startIndex) {\n      newIndex = this.newEndIndex;\n      newPoint.row = this.newEndPosition.row;\n      newPoint.column = this.newEndPosition.column;\n    }\n    return { point: newPoint, index: newIndex };\n  }\n  /**\n   * Edit a range to keep it in-sync with source code that has been edited.\n   *\n   * This function updates a range's start and end positions based on an edit\n   * operation. This is useful for editing ranges without requiring a tree\n   * or node instance.\n   */\n  editRange(range) {\n    const newRange = {\n      startIndex: range.startIndex,\n      startPosition: { ...range.startPosition },\n      endIndex: range.endIndex,\n      endPosition: { ...range.endPosition }\n    };\n    if (range.endIndex >= this.oldEndIndex) {\n      if (range.endIndex !== Number.MAX_SAFE_INTEGER) {\n        newRange.endIndex = this.newEndIndex + (range.endIndex - this.oldEndIndex);\n        newRange.endPosition = {\n          row: this.newEndPosition.row + (range.endPosition.row - this.oldEndPosition.row),\n          column: range.endPosition.row === this.oldEndPosition.row ? this.newEndPosition.column + (range.endPosition.column - this.oldEndPosition.column) : range.endPosition.column\n        };\n        if (newRange.endIndex < this.newEndIndex) {\n          newRange.endIndex = Number.MAX_SAFE_INTEGER;\n          newRange.endPosition = { row: Number.MAX_SAFE_INTEGER, column: Number.MAX_SAFE_INTEGER };\n        }\n      }\n    } else if (range.endIndex > this.startIndex) {\n      newRange.endIndex = this.startIndex;\n      newRange.endPosition = { ...this.startPosition };\n    }\n    if (range.startIndex >= this.oldEndIndex) {\n      newRange.startIndex = this.newEndIndex + (range.startIndex - this.oldEndIndex);\n      newRange.startPosition = {\n        row: this.newEndPosition.row + (range.startPosition.row - this.oldEndPosition.row),\n        column: range.startPosition.row === this.oldEndPosition.row ? this.newEndPosition.column + (range.startPosition.column - this.oldEndPosition.column) : range.startPosition.column\n      };\n      if (newRange.startIndex < this.newEndIndex) {\n        newRange.startIndex = Number.MAX_SAFE_INTEGER;\n        newRange.startPosition = { row: Number.MAX_SAFE_INTEGER, column: Number.MAX_SAFE_INTEGER };\n      }\n    } else if (range.startIndex > this.startIndex) {\n      newRange.startIndex = this.startIndex;\n      newRange.startPosition = { ...this.startPosition };\n    }\n    return newRange;\n  }\n};\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 = /* @__PURE__ */ 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  // @ts-expect-error: never read\n  [0] = 0;\n  // Internal handle for Wasm\n  /** @internal */\n  // @ts-expect-error: never read\n  [1] = 0;\n  // Internal handle for Wasm\n  /** @internal */\n  // @ts-expect-error: never read\n  [2] = 0;\n  // Internal handle for Wasm\n  /** @internal */\n  // @ts-expect-error: never read\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  // @ts-expect-error: never read\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 major_version = C.getValue(address, \"i32\");\n  const minor_version = C.getValue(address += SIZE_OF_INT, \"i32\");\n  const patch_version = C.getValue(address += SIZE_OF_INT, \"i32\");\n  return { major_version, minor_version, patch_version };\n}\n__name(unmarshalLanguageMetadata, \"unmarshalLanguageMetadata\");\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   * 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_wasm(this[0]);\n    const length = C.getValue(TRANSFER_BUFFER, \"i32\");\n    if (length === 0) return null;\n    return unmarshalLanguageMetadata(TRANSFER_BUFFER + SIZE_OF_INT);\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   * 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 binary2;\n    if (input instanceof Uint8Array) {\n      binary2 = input;\n    } else if (globalThis.process?.versions.node) {\n      const fs2 = await import(\"fs/promises\");\n      binary2 = await fs2.readFile(input);\n    } else {\n      const response = await fetch(input);\n      if (!response.ok) {\n        const body2 = await response.text();\n        throw new Error(`Language.load failed with status ${response.status}.\n\n${body2}`);\n      }\n      const retryResp = response.clone();\n      try {\n        binary2 = await WebAssembly.compileStreaming(response);\n      } catch (reason) {\n        console.error(\"wasm streaming compile failed:\", reason);\n        console.error(\"falling back to ArrayBuffer instantiation\");\n        binary2 = new Uint8Array(await retryResp.arrayBuffer());\n      }\n    }\n    const mod = await C.loadWebAssemblyModule(binary2, { 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_web_tree_sitter = __toESM(require_web_tree_sitter(), 1);\nvar Module2 = null;\nasync function initializeBinding(moduleOptions) {\n  return Module2 ??= await (0, import_web_tree_sitter.default)(moduleOptions);\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_abi_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 callback, \n   * 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  /** 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\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 startContainingPosition = options.startContainingPosition ?? ZERO_POINT;\n    const endContainingPosition = options.endContainingPosition ?? ZERO_POINT;\n    const startContainingIndex = options.startContainingIndex ?? 0;\n    const endContainingIndex = options.endContainingIndex ?? 0;\n    const matchLimit = options.matchLimit ?? 4294967295;\n    const maxStartDepth = options.maxStartDepth ?? 4294967295;\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 (endContainingIndex !== 0 && startContainingIndex > endContainingIndex) {\n      throw new Error(\"`startContainingIndex` cannot be greater than `endContainingIndex`\");\n    }\n    if (endContainingPosition !== ZERO_POINT && (startContainingPosition.row > endContainingPosition.row || startContainingPosition.row === endContainingPosition.row && startContainingPosition.column > endContainingPosition.column)) {\n      throw new Error(\"`startContainingPosition` cannot be greater than `endContainingPosition`\");\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      startContainingPosition.row,\n      startContainingPosition.column,\n      endContainingPosition.row,\n      endContainingPosition.column,\n      startContainingIndex,\n      endContainingIndex,\n      matchLimit,\n      maxStartDepth\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] = { 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 startContainingPosition = options.startContainingPosition ?? ZERO_POINT;\n    const endContainingPosition = options.endContainingPosition ?? ZERO_POINT;\n    const startContainingIndex = options.startContainingIndex ?? 0;\n    const endContainingIndex = options.endContainingIndex ?? 0;\n    const matchLimit = options.matchLimit ?? 4294967295;\n    const maxStartDepth = options.maxStartDepth ?? 4294967295;\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 (endContainingIndex !== 0 && startContainingIndex > endContainingIndex) {\n      throw new Error(\"`startContainingIndex` cannot be greater than `endContainingIndex`\");\n    }\n    if (endContainingPosition !== ZERO_POINT && (startContainingPosition.row > endContainingPosition.row || startContainingPosition.row === endContainingPosition.row && startContainingPosition.column > endContainingPosition.column)) {\n      throw new Error(\"`startContainingPosition` cannot be greater than `endContainingPosition`\");\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      startContainingPosition.row,\n      startContainingPosition.column,\n      endContainingPosition.row,\n      endContainingPosition.column,\n      startContainingIndex,\n      endContainingIndex,\n      matchLimit,\n      maxStartDepth\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// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  CaptureQuantifier,\n  Edit,\n  LANGUAGE_VERSION,\n  Language,\n  LookaheadIterator,\n  MIN_COMPATIBLE_VERSION,\n  Node,\n  Parser,\n  Query,\n  Tree,\n  TreeCursor\n});\nmodule.exports.default = module.exports;\n//# sourceMappingURL=web-tree-sitter.cjs.map\n","// The module cache\nconst __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tconst 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\tconst 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","const getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nlet 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\tconst ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tconst 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/value functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tif(Array.isArray(definition)) {\n\t\tvar i = 0;\n\t\twhile(i < definition.length) {\n\t\t\tvar key = definition[i++];\n\t\t\tvar binding = definition[i++];\n\t\t\tif(!__webpack_require__.o(exports, key)) {\n\t\t\t\tif(binding === 0) {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, value: definition[i++] });\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: binding });\n\t\t\t\t}\n\t\t\t} else if(binding === 0) { i++; }\n\t\t}\n\t} else {\n\t\tfor(var key in definition) {\n\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t\t}\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(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\nlet __webpack_exports__ = __webpack_require__(186);\n"],"names":["fs","__importStar","__webpack_require__","nesting_1","cyclomatic_1","cognitive_1","cliModes_1","VALUE_FLAGS","resolveThresholdOverride","override","defaults","undefined","mediumThreshold","highThreshold","async","parsed","argv","paths","flagValues","Map","i","length","arg","startsWith","name","slice","includes","set","push","flag","get","numberFlag","value","Number","baseRef","report","nesting","cyclomatic","cognitive","parseArgs","process","thresholds","DEFAULT_NESTING_THRESHOLDS","DEFAULT_CYCLOMATIC_THRESHOLDS","DEFAULT_COGNITIVE_THRESHOLDS","buildThresholds","reportFormat","runDiff","printUsage","exit","existsSync","statSync","isFile","runLegacySingleFile","runScan","main","catch","error","console","exports","filePath","languages_1","resolveLanguageForFile","sourceCode","readFileSync","violations","analyzeFile","log","JSON","stringify","hasBlockingViolation","some","v","severity","types_1","SEVERITY","HIGH","MEDIUM","files","scan_1","resolveSupportedFiles","results","path","relative","cwd","summary","report_1","summarize","counts","renderHumanReport","renderMarkdownReport","totalCounts","hasBlockingViolations","explicitPaths","rootDir","ignorePatterns","esaignore_1","loadIgnorePatterns","changedFiles","child_process_1","execFileSync","encoding","split","map","line","trim","filter","Boolean","changedFilesFromGit","isIgnored","resolve","headSummaries","baseSummaries","headSource","headViolations","summarizeFile","baseSource","readAtRef","baseViolations","entries","diffSummaries","renderDiffMarkdown","entry","status","Parser","Language","analyze_1","parserCache","adapter","parser","cached","init","grammarPath","join","__dirname","grammar","load","setLanguage","loadParser","tree","parse","analyzeSource","ref","stdio","sourceText","language","fileName","positions","position_1","createPositionLookup","analyzeNesting","analyzeFunctionComplexity","analyzeCognitiveComplexity","coherence_1","analyzeFileCoherence","coherence","DEFAULT_COHERENCE_THRESHOLDS","magicNumber_1","analyzeMagicNumbers","magicNumber","DEFAULT_MAGIC_NUMBER_OPTIONS","magicString_1","analyzeMagicStrings","magicString","DEFAULT_MAGIC_STRING_OPTIONS","parameterCount_1","analyzeParameterCount","inversion_1","analyzeInversionOpportunities","primitiveObsession_1","analyzePrimitiveObsession","matchOpportunity_1","analyzeMatchOpportunities","matchOpportunity","DEFAULT_MATCH_OPPORTUNITY_THRESHOLDS","logicalControlFlow_1","analyzeLogicalControlFlow","opaqueBoolean_1","analyzeOpaqueBooleanLiteral","suppressed","suppressionNotes","suppressions_1","applySuppressions","traverse","node","isFunctionDefinition","complexity","calculateCognitiveComplexity","position","toPosition","startIndex","column","type","VIOLATION_TYPE","COGNITIVE","message","hotspots","findCognitiveHotspots","child","children","rootNode","functionNode","onContribution","score","nodeTypes","add","amount","walkNested","walk","entersNestedScope","booleanOperator","getBooleanOperator","parent","cognitiveNestedDecisionTypes","elseClause","conditionalExpression","lambda","weight","functions","imports","isNamed","importStatement","importFromStatement","text","collectFunctionsAndImports","checkFunctionCountSprawl","checkLargeFunctionSprawl","checkImportSprawl","violation","leadingNameWord","nameNode","find","c","match","exec","toLowerCase","baseName","pop","isUtilsFile","singleDomain","minShare","leadingWords","word","wordCounts","Math","max","values","looksLikeSingleDomain","singleDomainNameShare","COHERENCE","largeFunctions","fn","lineCount","endPosition","row","startPosition","largeFunctionLines","maxLargeFunctions","countDecisionPoints","isRoot","decisionNodeTypes","isTryElseClause","calculateCyclomaticComplexity","COMPLEXITY","findCyclomaticHotspots","depth","nextDepth","body","block","flatMap","statements","comment","firstStatement","ifStatement","ifBody","totalLines","endIndex","INVERSION","currentNode","nestingLevel","validationChecks","nestingControlTypes","firstCheck","analyzeNestedValidation","maxNesting","nestedIfLocation","countNesting","currentDepth","analyzeNestedIfs","analyzeFunction","operator","expressionStatement","LOGICAL_CONTROL_FLOW","LOW","options","enabled","hasEnclosingFunction","assignmentNode","ancestor","integerLiteral","floatLiteral","rawValue","parseFloat","isNaN","signedValue","allowlist","assignment","isExplicitConstant","grandparent","module","exportStatement","isInConstantContext","subscriptNodeTypes","isIndexPosition","isDefaultParameterValue","MAGIC","candidates","stringLiteral","content","candidate","getEqualityComparisons","left","right","id","isEqualityComparisonOperand","container","getMembershipComparisons","isMembershipOperand","isKeyOrIndexPosition","isDecisionPoint","isDocstring","isFormattedOrInterpolatedString","isExempt","byContent","group","minDuplicates","first","consumed","Set","has","topIfNode","branches","ifNode","flatSiblings","getElseIfBranches","current","nestedIf","collectChainBranches","forEach","branch","minBranches","perBranchDiscriminants","branchNode","otherBranches","found","isVariableRef","variableReferenceNodeTypes","isLiteral","literalValue","variable","collectBranchDiscriminants","b","discriminants","commonVariable","d","every","MATCH_OPPORTUNITY","analyzeChain","NESTING","isBooleanLiteral","isPositionalCallArgument","OPAQUE_BOOLEAN","buildViolation","findParametersNode","params","parameters","paramCount","parameterChildTypes","PARAMETERS","parametersType","paramsNode","keywordOnly","typed","n","keywordOnlyBoundaryTypes","extracted","extractTypedParameter","a","primitiveTypeNames","PRIMITIVE_OBSESSION","distinctTypeAdvice","findParameterCollisions","valuesByVariable","firstOccurrence","record","varNode","key","stripQuotes","size","sample","Array","from","findStringlyTypedControlFlow","ignorePath","ESAIGNORE_FILENAME","replace","absolutePath","patterns","relPath","sep","basename","pattern","escaped","part","RegExp","basenameGlobToRegExp","test","matchesLiteralPattern","lineStartOffsets","offset","low","high","mid","ceil","severityCounts_1","emptyCounts","totalScore","file","medium","cleanCount","f","lines","result","byType","__exportStar","base","head","baseByPath","baseScore","delta","headScore","String","STATUS_ICON","statusCounts","reduce","EMPTY_STATUS_COUNTS","worsened","improved","new","unchanged","complexityToScore","classifyScore","classifyComplexityScore","flagged","r","sort","fileScore","SCORE_LEGEND","renderFileSection","fileScores","worst","repoLevel","toFixed","RISK_LABEL","RISK_DESCRIPTION","riskCounts","none","critical","totalFindings","COMPLEXITY_CURVE","MAX_COMPLEXITY_VALUE","MAX_COMPLEXITY_SCORE","prev","next","ratio","round","CATEGORY_LABEL","NAMING","SUPPRESSION","CATEGORY_BLURB","COMPLEXITY_VALUE_PATTERN","extractComplexityValue","describeCategoryFindings","label","level","describeComplexityFindings","severityText","blurb","complexityValues","risk","list","description","inputs","ignore","input","expandGlobLike","stat","isDirectory","isPathIgnored","walkDirectory","absolute","IGNORED_DIR_NAMES","targetPath","dir","readdirSync","withFileTypes","fullPath","starIndex","indexOf","prefixEnd","lastIndexOf","prefixDir","suffix","extension","endsWith","suppressions","lineText","DIRECTIVE_PATTERN","types","unknownTypes","raw","tokens","token","KNOWN_TYPES","parseTypeList","index","scope","standalone","parseSuppressions","suppressedCounts","s","remaining","coversLine","suppression","violationLine","scopeText","Object","FSHARP","forStatement","whileStatement","opToken","patternNode","typeNode","operands","rawRight","dotIndex","languageId","EXTENSION_TO_LANGUAGE_ID","Y","python_1","fsharp_1","typescript_1","kotlin_1","python","PYTHON","fsharp","typescript","TYPESCRIPT","kotlin","KOTLIN","typeIdentifier","siblings","findIndex","valueArgument","modifiers","modifier","allStrings","methodName","typeAnnotation","require","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","__create","create","__defProp","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__getProtoOf","getPrototypeOf","__hasOwnProp","prototype","hasOwnProperty","__name","target","configurable","__commonJS","cb","mod","__export","all","name2","enumerable","__copyProps","to","except","desc","call","__toESM","isNodeMode","__esModule","__toCommonJS","require_web_tree_sitter","Module","_scriptName","document","currentScript","src","moduleArg","moduleRtn","ENVIRONMENT_IS_WEB","window","ENVIRONMENT_IS_WORKER","WorkerGlobalScope","ENVIRONMENT_IS_NODE","versions","currentQueryProgressCallback","currentProgressCallback","currentLogCallback","currentParseCallback","arguments_","thisProgram","quit_","toThrow","__filename","scriptDirectory","readAsync","readBinary","locateFile","filename","isFileURI","URL","binary2","exitCode","href","url","xhr","XMLHttpRequest","open","responseType","send","Uint8Array","response","Promise","reject","onload","onerror","fetch","credentials","ok","arrayBuffer","Error","out","bind","err","dynamicLibraries","wasmBinary","ABORT","EXITSTATUS","readyPromiseResolve","readyPromiseReject","wasmMemory","HEAP8","HEAPU8","HEAP16","HEAPU16","HEAP32","HEAPU32","HEAPF32","HEAPF64","HEAP64","HEAPU64","HEAP_DATA_VIEW","runtimeInitialized","updateMemoryViews","buffer","Int8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","BigInt64Array","BigUint64Array","DataView","LE_HEAP_UPDATE","initMemory","INITIAL_MEMORY","WebAssembly","Memory","initial","maximum","__RELOC_FUNCS__","wasmBinaryFile","preRun","addOnPreRun","shift","callRuntimeCallbacks","onPreRuns","initRuntime","wasmExports","onPostCtors","preMain","postRun","addOnPostRun","onPostRuns","abort","what","e","RuntimeError","findWasmBinary","getBinarySync","getWasmBinary","binaryFile","instantiateArrayBuffer","instantiate","reason","instantiateAsync","instantiateStreaming","getWasmImports","env","wasmImports","wasi_snapshot_preview1","Proxy","GOTHandler","createWasm","receiveInstance","instance2","module2","relocateExports","metadata2","getDylinkMetadata","neededDynlibs","concat","mergeLibSymbols","LDSO","loadDylibs","assignWasmExports","receiveInstantiationResult","result2","info2","inst","ExitStatus","this","constructor","GOT","currentModuleWeakSymbols","obj","symName","rtn","Global","mutable","required","LE_ATOMICS_NATIVE_BYTE_ORDER","LE_HEAP_LOAD_F32","byteOffset","getFloat32","LE_HEAP_LOAD_F64","getFloat64","LE_HEAP_LOAD_I16","getInt16","LE_HEAP_LOAD_I32","getInt32","LE_HEAP_LOAD_I64","getBigInt64","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_I64","setBigInt64","LE_HEAP_STORE_U32","setUint32","callbacks","UTF8Decoder","TextDecoder","findStringEnd","heapOrArray","idx","maxBytesToRead","ignoreNul","maxIdx","UTF8ArrayToString","endPtr","decode","subarray","str","u0","u1","u2","fromCharCode","ch","end","getU8","getLEB","ret","mul","byte","getString","len","getStringList","count2","failIf","condition","dylinkSection","customSections","int32View","section_size","customSection","tlsExports","weakImports","runtimePaths","subsectionType","subsectionSize","memorySize","memoryAlign","tableSize","tableAlign","count","symname","getValue","ptr","newDSO","handle2","syms","dso","refcount","Infinity","global","loadedLibsByName","loadedLibsByHandle","___heap_base","alignMemory","alignment","getMemory","_calloc","isInternalSym","uleb128EncodeWithLen","arr","wasmTypeCodes","p","j","generateTypePack","convertJsFunctionToWasm","func2","sig","bytes","of","Instance","wasmTableMirror","wasmTable","Table","element","getWasmTableEntry","funcPtr","updateTableMap","functionsInTableMap","i2","item","getFunctionAddress","WeakMap","freeTableIndexes","getEmptyTableSlot","setWasmTableEntry","addFunction","err2","TypeError","wrapped","updateGOT","exports2","memoryBase2","relocated","isSymbolDefined","existing","stub","dynCall","args2","promising","rtn2","stackSave","_emscripten_stack_get_current","stackRestore","val","__emscripten_stack_restore","createInvokeFunction","sp","_setThrew","resolveGlobalSymbol","direct","sym","addOnPostCtor","UTF8ToString","loadWebAssemblyModule","binary","flags","libName","localScope","handle","metadata","loadModule","memAlign","pow","memoryBase","tableBase","moduleExports","resolveSymbol","resolved","grow","proxyHandler","stubs","prop","proxy","info","postInstantiation","instance","addEmAsm","addr","args","arity","func","ASM_CONSTS","start","eval","allowUndefined","reportUndefinedSymbols","stop","jsString","addEmJs","cSig","jsArgs","jsArg","parts","applyRelocs","loadAsync","rpath","parentLibPath","chain","dynNeeded","then","loadDynamicLibrary","needed","libName2","exp","setImport","main_alias","asyncLoad","flags2","nodelete","localScope2","assign","loadLibData","data","dataSize","libData","libFile","getExports","moduleLoaded","runDependencies","dependenciesFulfilled","removeRunDependency","callback","addRunDependency","lib","noExitRuntime","setValue","BigInt","___memory_base","___stack_high","___stack_low","___stack_pointer","___table_base","__abort_js","getHeapMax","growMemory","pages","byteLength","_emscripten_resize_heap","requestedSize","oldSize","maxHeapSize","cutDown","overGrownHeapSize","min","newSize","_fd_close","fd","INT53_MAX","INT53_MIN","bigintToI53Checked","num","NaN","_fd_seek","whence","newOffset","printCharBuffers","printChar","stream","curr","_fd_write","iov","iovcnt","pnum","_tree_sitter_log_callback","isLexMessage","messageAddress","_tree_sitter_parse_callback","inputBufferAddress","lengthAddress","string","stringToUTF16","_tree_sitter_progress_callback","currentOffset","hasError","_tree_sitter_query_progress_callback","runtimeKeepaliveCounter","keepRuntimeAlive","_proc_exit","code","exitJS","implicit","handleException","lengthBytesUTF8","charCodeAt","stringToUTF8Array","heap","outIdx","maxBytesToWrite","startIdx","endIdx","u","codePointAt","stringToUTF8","outPtr","stackAlloc","sz","__emscripten_stack_alloc","stringToUTF8OnStack","AsciiToString","startPtr","numCharsToWrite","codeUnit","unsigned","x","_malloc","_realloc","_free","_ts_range_edit","_memcmp","_ts_language_symbol_count","_ts_language_state_count","_ts_language_abi_version","_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_point_edit","_ts_parser_delete","_ts_parser_reset","_ts_parser_set_language","_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_metadata_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","wasmExports2","__heap_base","__indirect_function_table","__memory_base","__stack_high","__stack_low","__stack_pointer","__table_base","_abort_js","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","callMain","entryFunction","unshift","argc","argv_ptr","run","doRun","setTimeout","default","apply","index_exports","CaptureQuantifier","Edit","LANGUAGE_VERSION","LookaheadIterator","MIN_COMPATIBLE_VERSION","Node","Query","Tree","TreeCursor","oldEndPosition","newEndPosition","oldEndIndex","newEndIndex","editPoint","point","newIndex","newPoint","originalRow","editRange","range","newRange","MAX_SAFE_INTEGER","SIZE_OF_SHORT","SIZE_OF_INT","SIZE_OF_CURSOR","SIZE_OF_NODE","SIZE_OF_POINT","SIZE_OF_RANGE","ZERO_POINT","INTERNAL","Symbol","C","assertInternal","isPoint","setModule","internal","address","currentTypeId","currentType","reset","stateId","resetState","iterator","done","getText","textCallback","_Tree","copy","unmarshalNode","rootNodeWithOffset","offsetBytes","offsetExtent","TRANSFER_BUFFER","marshalPoint","edit","marshalEdit","getChangedRanges","other","unmarshalRange","getIncludedRanges","_TreeCursor","unmarshalTreeCursor","marshalTreeCursor","currentFieldId","currentFieldName","fields","currentDescendantIndex","nodeType","nodeTypeId","nodeStateId","nodeId","nodeIsNamed","nodeIsMissing","nodeText","unmarshalPoint","gotoFirstChild","gotoLastChild","gotoParent","gotoNextSibling","gotoPreviousSibling","gotoDescendant","goalDescendantIndex","gotoFirstChildForIndex","goalIndex","gotoFirstChildForPosition","goalPosition","marshalNode","resetTo","cursor","_children","_namedChildren","typeId","grammarId","grammarType","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","subbedPointRow","subbedPointColumn","toString","unmarshalCaptures","query","patternIndex","captureIndex","captureNames","marshalRange","unmarshalLanguageMetadata","major_version","minor_version","patch_version","LANGUAGE_FUNCTION_REGEX","_Language","abiVersion","fieldCount","stateCount","fieldIdForName","fieldNameForId","idForNodeType","named","typeLength","typeAddress","nodeTypeCount","nodeTypeForId","nodeTypeIsNamed","nodeTypeIsVisible","supertypes","subtypes","supertype","nextState","lookaheadIterator","globalThis","fs2","t","readFile","body2","retryResp","clone","compileStreaming","symbolNames","keys","functionName","languageAddress","import_web_tree_sitter","Module2","initializeBinding","moduleOptions","checkModule","logCallback","initialize","version","oldTree","progressCallback","rangeCount","rangeAddress","includedRanges","treeAddress","setLogger","getLogger","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","parseAnyPredicate","steps","textPredicates","isPositive","matchAll","captureName1","captureName2","captures","nodes1","nodes2","compare","n1","n2","positive","captureName","stringValue","matches","doesNotMatch","nodes","parseMatchPredicate","regex","parseAnyOfPredicate","stringSteps","parseIsPredicate","assertedProperties","refutedProperties","properties","parseSetDirective","setProperties","parsePattern","stepType","stepValueId","stringValues","predicates","exceededMatchLimit","captureQuantifiers","matchLimit","source","sourceLength","sourceAddress","errorId","errorByte","errorIndex","stringCount","captureCount","patternCount","nameAddress","nameLength","captureQuantifiersArray","quantifier","valueAddress","predicatesAddress","stepCount","stepAddress","freeze","startContainingPosition","endContainingPosition","startContainingIndex","endContainingIndex","maxStartDepth","rawCount","startAddress","didExceedMatchLimit","filteredCount","capture","predicatesForPattern","disableCapture","captureNameLength","captureNameAddress","disablePattern","startIndexForPattern","endIndexForPattern","captureIndexForName","isPatternRooted","isPatternNonLocal","isPatternGuaranteedAtStep","byteIndex","__webpack_module_cache__","moduleId","cachedModule","__webpack_modules__","getProto","leafPrototypes","mode","ns","def","definition","binding","o","toStringTag","__webpack_exports__"],"sourceRoot":""}