code-gauge 1.8.0 → 1.10.0

package/dist/metrics.js.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.js","sources":["../src/metrics.ts"],"sourcesContent":["import Parser from 'tree-sitter';\nimport { createLanguageRegistry } from './languages.js';\nimport type {\n  CallGraphMetrics,\n  CodeMetrics,\n  CohesionMetrics,\n  CouplingMetrics,\n  DeclarationMetrics,\n  DuplicationMetrics,\n  FunctionMetrics,\n  HalsteadMetrics,\n  LanguageDefinition,\n  LanguageName,\n  MeasureOptions,\n  ModuleMetrics,\n  SyntaxFeatureMetrics,\n  TypeComplexityMetrics,\n} from './types.js';\n\nconst booleanOperators = new Set(['&&', '||', 'and', 'or']);\nconst operatorTexts = new Set([\n  '+',\n  '-',\n  '*',\n  '/',\n  '%',\n  '**',\n  '=',\n  '+=',\n  '-=',\n  '*=',\n  '/=',\n  '%=',\n  '==',\n  '!=',\n  '===',\n  '!==',\n  '<',\n  '<=',\n  '>',\n  '>=',\n  '!',\n  '~',\n  '&',\n  '|',\n  '^',\n  '<<',\n  '>>',\n  '=>',\n  'return',\n  'throw',\n  'yield',\n  'await',\n  'break',\n  'continue',\n]);\n\nconst operandNodeTypes = new Set([\n  'identifier',\n  'property_identifier',\n  'field_identifier',\n  'type_identifier',\n  'number',\n  'integer',\n  'float',\n  'integer_literal',\n  'float_literal',\n  'int_literal',\n  'rune_literal',\n  'imaginary_literal',\n  'string',\n  'string_literal',\n  'template_string',\n  'character_literal',\n  'char_literal',\n  'true',\n  'false',\n  'null',\n  'undefined',\n  'nil',\n]);\n\ninterface ComplexityResult {\n  cyclomaticComplexity: number;\n  cognitiveComplexity: number;\n  nestingDepth: number;\n}\n\ninterface CommentSpan {\n  line: number;\n  startColumn: number;\n  endColumn: number;\n}\n\ninterface FunctionAnalysis {\n  index: number;\n  name?: string;\n  startLine: number;\n  startColumn: number;\n  endLine: number;\n  returnsJsx: boolean;\n  cyclomaticComplexity: number;\n  cognitiveComplexity: number;\n  callCount: number;\n  parameterCount: number;\n  callees: Set<string>;\n  identifiers: Set<string>;\n}\n\ninterface StructuralMetrics {\n  callGraph: CallGraphMetrics;\n  cohesion: CohesionMetrics;\n  coupling: CouplingMetrics;\n  functions: FunctionMetrics[];\n  module: ModuleMetrics;\n  syntaxFeatures: SyntaxFeatureMetrics;\n  typeComplexity: TypeComplexityMetrics;\n}\n\nexport class TreeMeasurer {\n  private readonly registry = createLanguageRegistry();\n\n  registerLanguage(language: LanguageDefinition): void {\n    this.registry.set(language.name, language);\n    for (const alias of language.aliases ?? []) {\n      this.registry.set(alias, language);\n    }\n  }\n\n  getSupportedLanguages(): LanguageName[] {\n    return [...new Set([...this.registry.values()].map((language) => language.name))];\n  }\n\n  measure(code: string, options: MeasureOptions): CodeMetrics {\n    const language = this.registry.get(options.language);\n    if (!language) {\n      throw new Error(`Unsupported language: ${options.language}`);\n    }\n\n    const parser = new Parser();\n    parser.setLanguage(language.parserLanguage);\n    const tree = parser.parse(code, undefined, {\n      bufferSize: code.length + 1,\n    });\n    const root = tree.rootNode;\n    const functions = collectNodes(root, new Set(language.functionNodeTypes));\n    const structuralMetrics = measureStructuralMetrics(root, functions, language);\n    const functionMetrics = structuralMetrics.functions;\n    const globalComplexity = measureComplexity(root, language, 0, false);\n    const lines = measureLines(code, root);\n    const halstead = measureHalstead(root, code);\n\n    return {\n      language: language.name,\n      bytes: Buffer.byteLength(code),\n      lines,\n      functions: functionMetrics,\n      classCount: collectNodes(root, new Set(language.classNodeTypes)).length,\n      functionCount: functionMetrics.length,\n      cyclomaticComplexity: globalComplexity.cyclomaticComplexity,\n      maxCyclomaticComplexity: maxMetric(functionMetrics, 'cyclomaticComplexity'),\n      cognitiveComplexity: globalComplexity.cognitiveComplexity,\n      maxCognitiveComplexity: maxMetric(functionMetrics, 'cognitiveComplexity'),\n      nestingDepth: globalComplexity.nestingDepth,\n      callGraph: structuralMetrics.callGraph,\n      coupling: structuralMetrics.coupling,\n      module: structuralMetrics.module,\n      cohesion: structuralMetrics.cohesion,\n      syntaxFeatures: structuralMetrics.syntaxFeatures,\n      typeComplexity: structuralMetrics.typeComplexity,\n      duplication: measureDuplication(root),\n      halstead,\n      maintainabilityIndex: calculateMaintainabilityIndex(\n        halstead.volume,\n        globalComplexity.cyclomaticComplexity,\n        lines.code\n      ),\n      syntaxTree: options.includeSyntaxTree ? root.toString() : undefined,\n    };\n  }\n}\n\nexport const defaultMeasurer = new TreeMeasurer();\n\nexport function measureCode(code: string, options: MeasureOptions): CodeMetrics {\n  return defaultMeasurer.measure(code, options);\n}\n\nfunction measureStructuralMetrics(\n  root: Parser.SyntaxNode,\n  functions: Parser.SyntaxNode[],\n  language: LanguageDefinition\n): StructuralMetrics {\n  const analyses = functions.map((node, index) => analyzeFunction(node, language, index));\n  const callGraph = measureCallGraph(analyses);\n  const functionsWithGraph = analyses.map((analysis) => ({\n    name: analysis.name,\n    startLine: analysis.startLine,\n    startColumn: analysis.startColumn,\n    endLine: analysis.endLine,\n    returnsJsx: analysis.returnsJsx,\n    cyclomaticComplexity: analysis.cyclomaticComplexity,\n    cognitiveComplexity: analysis.cognitiveComplexity,\n    callCount: analysis.callCount,\n    uniqueCalleeCount: analysis.callees.size,\n    fanIn: callGraph.fanInByIndex.get(analysis.index) ?? 0,\n    fanOut: callGraph.fanOutByIndex.get(analysis.index) ?? 0,\n    parameterCount: analysis.parameterCount,\n    recursive: callGraph.recursiveIndexes.has(analysis.index),\n  }));\n\n  return {\n    functions: functionsWithGraph,\n    callGraph: callGraph.metrics,\n    coupling: measureCoupling(root, language),\n    module: measureModule(root, language),\n    cohesion: measureCohesion(analyses),\n    syntaxFeatures: measureSyntaxFeatures(root),\n    typeComplexity: measureTypeComplexity(root),\n  };\n}\n\nfunction analyzeFunction(node: Parser.SyntaxNode, language: LanguageDefinition, index: number): FunctionAnalysis {\n  const complexity = measureComplexity(node, language, 0, true);\n  const calls = collectCalls(node, language);\n  return {\n    index,\n    name: findFunctionName(node),\n    startLine: node.startPosition.row + 1,\n    startColumn: node.startPosition.column,\n    endLine: node.endPosition.row + 1,\n    returnsJsx: returnsJsx(node, language),\n    cyclomaticComplexity: complexity.cyclomaticComplexity,\n    cognitiveComplexity: complexity.cognitiveComplexity,\n    callCount: calls.callCount,\n    parameterCount: countParameters(node),\n    callees: calls.callees,\n    identifiers: collectIdentifiers(node),\n  };\n}\n\n/** Counts declared parameters of a function/method, ignoring punctuation and comments. */\nfunction countParameters(node: Parser.SyntaxNode): number {\n  const parametersNode =\n    node.childForFieldName('parameters') ??\n    node.namedChildren.find((child) => child.type === 'formal_parameters' || child.type === 'parameter_list');\n  if (!parametersNode) {\n    return 0;\n  }\n\n  // Rust's `self` receiver is not a declared parameter.\n  return parametersNode.namedChildren.filter((child) => child.type !== 'comment' && child.type !== 'self_parameter')\n    .length;\n}\n\nfunction measureCallGraph(analyses: FunctionAnalysis[]): {\n  fanInByIndex: Map<number, number>;\n  fanOutByIndex: Map<number, number>;\n  metrics: CallGraphMetrics;\n  recursiveIndexes: Set<number>;\n} {\n  const indexesByName = mapUniqueFunctionIndexesByName(analyses);\n  const functionNames = new Set(indexesByName.keys());\n  const fanInByIndex = new Map<number, number>();\n  const fanOutByIndex = new Map<number, number>();\n  const graph = new Map<number, Set<number>>();\n  let callCount = 0;\n  let internalCallCount = 0;\n  const allCallees = new Set<string>();\n\n  for (const analysis of analyses) {\n    callCount += analysis.callCount;\n    for (const callee of analysis.callees) {\n      allCallees.add(callee);\n    }\n\n    const internalCalleeNames = new Set([...analysis.callees].filter((callee) => functionNames.has(callee)));\n    const internalCalleeIndexes = new Set<number>();\n    for (const callee of internalCalleeNames) {\n      const calleeIndex = indexesByName.get(callee);\n      if (calleeIndex !== undefined) {\n        internalCalleeIndexes.add(calleeIndex);\n      }\n    }\n\n    graph.set(analysis.index, internalCalleeIndexes);\n    fanOutByIndex.set(analysis.index, internalCalleeNames.size);\n    internalCallCount += internalCalleeNames.size;\n    for (const calleeIndex of internalCalleeIndexes) {\n      fanInByIndex.set(calleeIndex, (fanInByIndex.get(calleeIndex) ?? 0) + 1);\n    }\n  }\n\n  const recursiveIndexes = findRecursiveIndexes(graph);\n\n  return {\n    fanInByIndex,\n    fanOutByIndex,\n    recursiveIndexes,\n    metrics: {\n      callCount,\n      uniqueCalleeCount: allCallees.size,\n      internalCallCount,\n      internalEdgeCount: sum([...graph.values()].map((callees) => callees.size)),\n      recursiveFunctionCount: recursiveIndexes.size,\n      maxFanIn: maxMapValue(fanInByIndex),\n      maxFanOut: maxMapValue(fanOutByIndex),\n      maxCallDepth: measureMaxCallDepth(graph),\n    },\n  };\n}\n\nfunction mapUniqueFunctionIndexesByName(analyses: FunctionAnalysis[]): Map<string, number> {\n  const indexesByName = new Map<string, number | undefined>();\n  for (const analysis of analyses) {\n    if (!analysis.name) {\n      continue;\n    }\n\n    indexesByName.set(analysis.name, indexesByName.has(analysis.name) ? undefined : analysis.index);\n  }\n  return new Map([...indexesByName.entries()].filter((entry): entry is [string, number] => entry[1] !== undefined));\n}\n\nfunction measureComplexity(\n  node: Parser.SyntaxNode,\n  language: LanguageDefinition,\n  nesting: number,\n  stopAtNestedFunctions: boolean\n): ComplexityResult {\n  let cyclomaticComplexity = 1;\n  let cognitiveComplexity = 0;\n  let nestingDepth = nesting;\n  const functionNodes = new Set(language.functionNodeTypes);\n  const decisionNodes = new Set(language.decisionNodeTypes);\n  const nestingNodes = new Set(language.nestingNodeTypes);\n\n  function visit(current: Parser.SyntaxNode, currentNesting: number, insideRoot: boolean): void {\n    if (stopAtNestedFunctions && !insideRoot && functionNodes.has(current.type)) {\n      return;\n    }\n\n    const isDecision = decisionNodes.has(current.type);\n    const isNesting = nestingNodes.has(current.type);\n\n    if (isDecision) {\n      cyclomaticComplexity += 1;\n      cognitiveComplexity += 1 + currentNesting;\n    }\n\n    if (isBooleanOperator(current)) {\n      cyclomaticComplexity += 1;\n      cognitiveComplexity += 1;\n    }\n\n    const childNesting = isNesting ? currentNesting + 1 : currentNesting;\n    nestingDepth = Math.max(nestingDepth, childNesting);\n\n    for (const child of current.children) {\n      visit(child, childNesting, false);\n    }\n  }\n\n  for (const child of node.children) {\n    visit(child, nesting, false);\n  }\n\n  return { cyclomaticComplexity, cognitiveComplexity, nestingDepth };\n}\n\nfunction isBooleanOperator(node: Parser.SyntaxNode): boolean {\n  if (node.isNamed) {\n    return false;\n  }\n\n  return booleanOperators.has(node.text);\n}\n\nfunction collectCalls(\n  root: Parser.SyntaxNode,\n  language: LanguageDefinition\n): { callCount: number; callees: Set<string> } {\n  const callees = new Set<string>();\n  const functionNodeTypes = new Set(language.functionNodeTypes);\n  let callCount = 0;\n\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): void {\n    if (!insideRoot && functionNodeTypes.has(node.type)) {\n      return;\n    }\n\n    if (isCallNode(node)) {\n      callCount += 1;\n      const callee = findCalleeName(node);\n      if (callee) {\n        callees.add(callee);\n      }\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child, false);\n    }\n  }\n\n  visit(root, true);\n  return { callCount, callees };\n}\n\nfunction collectIdentifiers(root: Parser.SyntaxNode): Set<string> {\n  const identifiers = new Set<string>();\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (node.type === 'identifier' || node.type === 'property_identifier' || node.type === 'field_identifier') {\n      identifiers.add(node.text);\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return identifiers;\n}\n\nfunction collectNodes(root: Parser.SyntaxNode, nodeTypes: Set<string>): Parser.SyntaxNode[] {\n  const nodes: Parser.SyntaxNode[] = [];\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (nodeTypes.has(node.type)) {\n      nodes.push(node);\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return nodes;\n}\n\nfunction returnsJsx(root: Parser.SyntaxNode, language: LanguageDefinition): boolean {\n  const functionNodeTypes = new Set(language.functionNodeTypes);\n\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): boolean {\n    if (!insideRoot && functionNodeTypes.has(node.type)) {\n      return false;\n    }\n\n    if (node.type === 'return_statement') {\n      return containsJsxExpression(node, functionNodeTypes) || containsReactCreateElementCall(node, functionNodeTypes);\n    }\n\n    if (\n      root.type === 'arrow_function' &&\n      node === getArrowFunctionBody(root) &&\n      node.type !== 'statement_block' &&\n      !functionNodeTypes.has(node.type)\n    ) {\n      return containsJsxExpression(node, functionNodeTypes) || containsReactCreateElementCall(node, functionNodeTypes);\n    }\n\n    for (const child of node.namedChildren) {\n      if (visit(child, false)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  return visit(root, true);\n}\n\nfunction getArrowFunctionBody(node: Parser.SyntaxNode): Parser.SyntaxNode | undefined {\n  return node.childForFieldName('body') ?? node.namedChild(node.namedChildCount - 1) ?? undefined;\n}\n\nfunction containsJsxExpression(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  return containsNode(\n    root,\n    functionNodeTypes,\n    (node) => node.type.startsWith('jsx_') || isJsxMappingCall(node, functionNodeTypes)\n  );\n}\n\nfunction containsReactCreateElementCall(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  return containsNode(root, functionNodeTypes, isReactCreateElementCall);\n}\n\nfunction containsNode(\n  root: Parser.SyntaxNode,\n  functionNodeTypes: Set<string>,\n  predicate: (node: Parser.SyntaxNode) => boolean\n): boolean {\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): boolean {\n    if (!insideRoot && functionNodeTypes.has(node.type)) {\n      return false;\n    }\n\n    if (predicate(node)) {\n      return true;\n    }\n\n    for (const child of node.namedChildren) {\n      if (visit(child, false)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  return visit(root, true);\n}\n\nfunction isJsxMappingCall(node: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  if (!isCallNode(node) || !isArrayMappingCallee(node.childForFieldName('function') ?? node.namedChild(0))) {\n    return false;\n  }\n\n  return node.namedChildren.some((child) => containsReturnedJsxFunction(child, functionNodeTypes));\n}\n\nfunction isArrayMappingCallee(node: Parser.SyntaxNode | null): boolean {\n  if (!node) {\n    return false;\n  }\n\n  const calleeName = findRightmostIdentifier(node);\n  return calleeName === 'map' || calleeName === 'flatMap';\n}\n\nfunction containsReturnedJsxFunction(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  if (functionNodeTypes.has(root.type)) {\n    return returnsJsxFromFunctionNode(root, functionNodeTypes);\n  }\n\n  return root.namedChildren.some((child) => containsReturnedJsxFunction(child, functionNodeTypes));\n}\n\nfunction returnsJsxFromFunctionNode(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  const body = root.type === 'arrow_function' ? getArrowFunctionBody(root) : undefined;\n  if (body && body.type !== 'statement_block' && !functionNodeTypes.has(body.type)) {\n    return containsJsxExpression(body, functionNodeTypes) || containsReactCreateElementCall(body, functionNodeTypes);\n  }\n\n  return containsOwnReturnNode(\n    root,\n    functionNodeTypes,\n    (node) => containsJsxExpression(node, functionNodeTypes) || containsReactCreateElementCall(node, functionNodeTypes)\n  );\n}\n\nfunction containsOwnReturnNode(\n  root: Parser.SyntaxNode,\n  functionNodeTypes: Set<string>,\n  predicate: (node: Parser.SyntaxNode) => boolean\n): boolean {\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): boolean {\n    if (!insideRoot && functionNodeTypes.has(node.type)) {\n      return false;\n    }\n\n    if (node.type === 'return_statement' && predicate(node)) {\n      return true;\n    }\n\n    for (const child of node.namedChildren) {\n      if (visit(child, false)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  return visit(root, true);\n}\n\nfunction measureModule(root: Parser.SyntaxNode, language: LanguageDefinition): ModuleMetrics {\n  const importSources = new Set<string>();\n\n  function visitImports(node: Parser.SyntaxNode): void {\n    if (isImportSourceNode(node)) {\n      for (const source of findImportSources(node, language, { expandPythonSubmodules: true })) {\n        importSources.add(source);\n      }\n    }\n\n    for (const child of node.namedChildren) {\n      visitImports(child);\n    }\n  }\n\n  visitImports(root);\n\n  return {\n    declarations: collectModuleDeclarations(root),\n    importSources: [...importSources],\n  };\n}\n\nfunction collectModuleDeclarations(root: Parser.SyntaxNode): DeclarationMetrics[] {\n  const exportedNames = collectExportedNames(root);\n  return root.namedChildren\n    .flatMap((child) => collectTopLevelDeclarations(child, false))\n    .map((declaration) => (exportedNames.has(declaration.name) ? { ...declaration, exported: true } : declaration));\n}\n\nfunction collectTopLevelDeclarations(node: Parser.SyntaxNode, exported: boolean): DeclarationMetrics[] {\n  if (isModuleExportNode(node)) {\n    return node.namedChildren.flatMap((child) => collectTopLevelDeclarations(child, true));\n  }\n\n  if (isDeclarationContainer(node)) {\n    return node.namedChildren.flatMap((child) => collectTopLevelDeclarations(child, exported));\n  }\n\n  return declarationFromNode(node, exported);\n}\n\nfunction declarationFromNode(node: Parser.SyntaxNode, exported: boolean): DeclarationMetrics[] {\n  if (!isTopLevelDeclarationNode(node)) {\n    return [];\n  }\n\n  const name = findDeclarationName(node);\n  return name ? [{ exported, name, startLine: node.startPosition.row + 1 }] : [];\n}\n\nfunction findDeclarationName(node: Parser.SyntaxNode): string | undefined {\n  if (node.type === 'method_declaration') {\n    return findGoMethodDeclarationName(node);\n  }\n\n  const nameNode = node.childForFieldName('name');\n  if (nameNode) {\n    return isDeclarationNameNode(nameNode) ? nameNode.text : undefined;\n  }\n\n  return node.namedChildren.find(isDeclarationNameNode)?.text;\n}\n\nfunction isModuleExportNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'export_statement' || node.type === 'export_declaration';\n}\n\nfunction isDeclarationContainer(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'lexical_declaration' ||\n    node.type === 'variable_declaration' ||\n    node.type === 'decorated_definition' ||\n    node.type === 'type_declaration' ||\n    node.type === 'const_declaration' ||\n    node.type === 'var_declaration' ||\n    node.type === 'var_spec_list'\n  );\n}\n\nfunction isTopLevelDeclarationNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'function_declaration' ||\n    node.type === 'function_definition' ||\n    node.type === 'function_item' ||\n    node.type === 'method_declaration' ||\n    node.type === 'class_declaration' ||\n    node.type === 'class_definition' ||\n    node.type === 'interface_declaration' ||\n    node.type === 'type_alias_declaration' ||\n    node.type === 'type_declaration' ||\n    node.type === 'type_spec' ||\n    node.type === 'const_spec' ||\n    node.type === 'var_spec' ||\n    node.type === 'variable_declarator' ||\n    node.type === 'struct_item' ||\n    node.type === 'enum_item' ||\n    node.type === 'union_item' ||\n    node.type === 'trait_item' ||\n    node.type === 'type_item' ||\n    node.type === 'const_item' ||\n    node.type === 'static_item' ||\n    node.type === 'mod_item'\n  );\n}\n\nfunction isDeclarationNameNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'identifier' ||\n    node.type === 'type_identifier' ||\n    node.type === 'property_identifier' ||\n    node.type === 'field_identifier'\n  );\n}\n\nfunction collectExportedNames(root: Parser.SyntaxNode): Set<string> {\n  const exportedNames = new Set<string>();\n\n  function visit(node: Parser.SyntaxNode, insideSourcedExport: boolean): void {\n    if (!insideSourcedExport && isExportSpecifierNode(node)) {\n      const name = findExportedName(node);\n      if (name) {\n        exportedNames.add(name);\n      }\n    }\n\n    const isSourcedExport =\n      insideSourcedExport || (isModuleExportNode(node) && node.childForFieldName('source') !== null);\n    for (const child of node.namedChildren) {\n      visit(child, isSourcedExport);\n    }\n  }\n\n  visit(root, false);\n  return exportedNames;\n}\n\nfunction isExportSpecifierNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'export_specifier' || node.type === 'namespace_export';\n}\n\nfunction findExportedName(node: Parser.SyntaxNode): string | undefined {\n  const nameNode =\n    node.childForFieldName('name') ?? node.childForFieldName('alias') ?? node.namedChildren.find(isDeclarationNameNode);\n  return nameNode && isDeclarationNameNode(nameNode) ? nameNode.text : undefined;\n}\n\nfunction findGoMethodDeclarationName(node: Parser.SyntaxNode): string | undefined {\n  const nameNode = node.childForFieldName('name');\n  const receiverTypeNode = node.childForFieldName('receiver')?.namedChildren[0]?.childForFieldName('type');\n  if (!nameNode || !isDeclarationNameNode(nameNode) || !receiverTypeNode) {\n    return nameNode && isDeclarationNameNode(nameNode) ? nameNode.text : undefined;\n  }\n\n  return `${normalizeGoReceiverType(receiverTypeNode.text)}.${nameNode.text}`;\n}\n\nfunction normalizeGoReceiverType(receiverType: string): string {\n  return receiverType.replaceAll(/\\s+/gu, '').replace(/^\\*+/u, '');\n}\n\nfunction measureCoupling(root: Parser.SyntaxNode, language: LanguageDefinition): CouplingMetrics {\n  const importSources = new Set<string>();\n  let importCount = 0;\n  let exportCount = 0;\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (isImportNode(node) || isDynamicImportNode(node)) {\n      importCount += 1;\n    }\n\n    if (isImportSourceNode(node)) {\n      for (const source of findImportSources(node, language, { expandPythonSubmodules: false })) {\n        importSources.add(source);\n      }\n    }\n\n    if (isExportNode(node)) {\n      exportCount += 1;\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n\n  const relativeImportCount = [...importSources].filter((source) =>\n    isRelativeImportSource(source, language.name)\n  ).length;\n\n  return {\n    importCount,\n    importSourceCount: importSources.size,\n    relativeImportCount,\n    externalImportCount: importSources.size - relativeImportCount,\n    exportCount,\n  };\n}\n\nfunction measureSyntaxFeatures(root: Parser.SyntaxNode): SyntaxFeatureMetrics {\n  const metrics: SyntaxFeatureMetrics = {\n    assignmentCount: 0,\n    awaitExpressionCount: 0,\n    loopStatementCount: 0,\n    mutableBindingCount: 0,\n    returnStatementCount: 0,\n    throwStatementCount: 0,\n    tryStatementCount: 0,\n  };\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (isAssignmentNode(node)) {\n      metrics.assignmentCount += 1;\n    }\n    if (isAwaitNode(node)) {\n      metrics.awaitExpressionCount += 1;\n    }\n    if (isLoopNode(node)) {\n      metrics.loopStatementCount += 1;\n    }\n    if (isMutableBindingNode(node)) {\n      metrics.mutableBindingCount += 1;\n    }\n    if (isReturnNode(node)) {\n      metrics.returnStatementCount += 1;\n    }\n    if (isThrowNode(node)) {\n      metrics.throwStatementCount += 1;\n    }\n    if (isTryNode(node)) {\n      metrics.tryStatementCount += 1;\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return metrics;\n}\n\nfunction isAssignmentNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'assignment_expression' ||\n    node.type === 'augmented_assignment_expression' ||\n    node.type === 'assignment_statement' ||\n    node.type === 'assignment' ||\n    node.type === 'augmented_assignment' ||\n    node.type === 'short_var_declaration' ||\n    node.type === 'compound_assignment_expr'\n  );\n}\n\nfunction isAwaitNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'await_expression' || node.type === 'await';\n}\n\nfunction isLoopNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'for_statement' ||\n    node.type === 'for_in_statement' ||\n    node.type === 'while_statement' ||\n    node.type === 'do_statement' ||\n    node.type === 'for_expression' ||\n    node.type === 'while_expression' ||\n    node.type === 'loop_expression'\n  );\n}\n\nfunction isMutableBindingNode(node: Parser.SyntaxNode): boolean {\n  return (\n    (node.type === 'lexical_declaration' && node.firstChild?.text === 'let') ||\n    (node.type === 'variable_declaration' && node.firstChild?.text === 'var') ||\n    node.type === 'var_declaration' ||\n    (node.type === 'let_declaration' && hasRustMutableLetBinding(node))\n  );\n}\n\n/**\n * A Rust `let` binds mutably via a direct `mut` (`let mut x = ...`) or a `mut` inside its\n * destructuring pattern — a `mut_pattern` (`let (mut a, b) = ...`) or a shorthand `field_pattern`\n * (`let Point { mut x } = ...`). Only the pattern is inspected so a borrow in the value such as\n * `let x = &mut y;` is not miscounted, and a `mut` under a `reference_pattern` (`let &mut x = y;`,\n * which binds `x` immutably) is excluded.\n */\nfunction hasRustMutableLetBinding(node: Parser.SyntaxNode): boolean {\n  if (node.children.some((child) => child.type === 'mutable_specifier')) {\n    return true;\n  }\n\n  const pattern = node.childForFieldName('pattern');\n  if (!pattern) {\n    return false;\n  }\n\n  return pattern\n    .descendantsOfType('mutable_specifier')\n    .some((specifier) => specifier.parent?.type !== 'reference_pattern');\n}\n\nfunction isReturnNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'return_statement' || node.type === 'return_expression';\n}\n\nfunction isThrowNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'throw_statement' || node.type === 'raise_statement';\n}\n\nfunction isTryNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'try_statement';\n}\n\nfunction measureCohesion(analyses: FunctionAnalysis[]): CohesionMetrics {\n  const allIdentifiers = new Set<string>();\n  const sharedIdentifiers = new Set<string>();\n  let overlapTotal = 0;\n  let pairCount = 0;\n\n  for (const analysis of analyses) {\n    for (const identifier of analysis.identifiers) {\n      allIdentifiers.add(identifier);\n    }\n  }\n\n  for (let leftIndex = 0; leftIndex < analyses.length; leftIndex += 1) {\n    for (let rightIndex = leftIndex + 1; rightIndex < analyses.length; rightIndex += 1) {\n      const left = analyses[leftIndex];\n      const right = analyses[rightIndex];\n      if (!left || !right) {\n        continue;\n      }\n\n      const intersection = intersectSets(left.identifiers, right.identifiers);\n      const unionSize = new Set([...left.identifiers, ...right.identifiers]).size;\n      for (const identifier of intersection) {\n        sharedIdentifiers.add(identifier);\n      }\n      overlapTotal += unionSize === 0 ? 0 : intersection.size / unionSize;\n      pairCount += 1;\n    }\n  }\n\n  return {\n    averageFunctionIdentifierOverlap: pairCount === 0 ? 1 : overlapTotal / pairCount,\n    sharedIdentifierCount: sharedIdentifiers.size,\n    uniqueIdentifierCount: allIdentifiers.size,\n  };\n}\n\nfunction measureTypeComplexity(root: Parser.SyntaxNode): TypeComplexityMetrics {\n  const metrics: TypeComplexityMetrics = {\n    typeAnnotationCount: 0,\n    typeAliasCount: 0,\n    interfaceCount: 0,\n    genericParameterCount: 0,\n    unionTypeCount: 0,\n    intersectionTypeCount: 0,\n    conditionalTypeCount: 0,\n    typeAssertionCount: 0,\n    nonNullAssertionCount: 0,\n    satisfiesExpressionCount: 0,\n  };\n\n  function visit(node: Parser.SyntaxNode): void {\n    switch (node.type) {\n      case 'type_annotation': {\n        metrics.typeAnnotationCount += 1;\n        break;\n      }\n      case 'type_alias_declaration': {\n        metrics.typeAliasCount += 1;\n        break;\n      }\n      case 'interface_declaration': {\n        metrics.interfaceCount += 1;\n        break;\n      }\n      case 'type_parameters':\n      case 'type_parameter': {\n        metrics.genericParameterCount += node.type === 'type_parameter' ? 1 : 0;\n        break;\n      }\n      case 'union_type': {\n        metrics.unionTypeCount += 1;\n        break;\n      }\n      case 'intersection_type': {\n        metrics.intersectionTypeCount += 1;\n        break;\n      }\n      case 'conditional_type': {\n        metrics.conditionalTypeCount += 1;\n        break;\n      }\n      case 'as_expression':\n      case 'type_assertion': {\n        metrics.typeAssertionCount += 1;\n        break;\n      }\n      case 'non_null_expression': {\n        metrics.nonNullAssertionCount += 1;\n        break;\n      }\n      case 'satisfies_expression': {\n        metrics.satisfiesExpressionCount += 1;\n        break;\n      }\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return metrics;\n}\n\nconst duplicateBlockTypes = new Set([\n  'statement_block',\n  'block',\n  'if_statement',\n  'for_statement',\n  'for_in_statement',\n  'while_statement',\n  'do_statement',\n  'try_statement',\n  'with_statement',\n  'switch_statement',\n  'switch_case',\n  'case_clause',\n  'match_statement',\n  'match_arm',\n  'except_clause',\n  'catch_clause',\n  'finally_clause',\n  'elif_clause',\n  'expression_statement',\n  'return_statement',\n  'return_expression',\n  'if_expression',\n  'for_expression',\n  'while_expression',\n  'loop_expression',\n  'match_expression',\n  'jsx_element',\n  'jsx_self_closing_element',\n]);\n\n/** Minimum subtree size (node count) for a block to be considered for duplication, to skip trivial repeats. */\nconst minDuplicateBlockSize = 24;\n\ninterface DuplicateCandidate {\n  node: Parser.SyntaxNode;\n  shape: string;\n  size: number;\n}\n\n/**\n * Detects copy-pasted code blocks within a file by grouping control-flow / block / JSX subtrees that\n * share the same syntactic shape (node types, ignoring identifiers and literals). Only maximal,\n * non-overlapping blocks are counted so nested matches are not double-counted. Literal-only structures\n * such as array or object data are excluded because their element nodes are not block types.\n */\nfunction measureDuplication(root: Parser.SyntaxNode): DuplicationMetrics {\n  const candidates: DuplicateCandidate[] = [];\n  const shapeCache = new Map<number, { shape: string; size: number }>();\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (duplicateBlockTypes.has(node.type)) {\n      const { size } = describeShape(node, shapeCache);\n      if (size >= minDuplicateBlockSize) {\n        const { shape } = describeShape(node, shapeCache);\n        candidates.push({ node, shape, size });\n      }\n    }\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n  visit(root);\n\n  const byShape = new Map<string, DuplicateCandidate[]>();\n  for (const candidate of candidates) {\n    const group = byShape.get(candidate.shape) ?? [];\n    group.push(candidate);\n    byShape.set(candidate.shape, group);\n  }\n\n  // Count larger blocks first and skip any candidate nested inside an already-counted duplicate.\n  const counted: DuplicateCandidate[] = [];\n  const consumed: Parser.SyntaxNode[] = [];\n  let duplicateBlockCount = 0;\n  let maxDuplicateBlockSize = 0;\n  const groupCounts = new Map<string, number>();\n  for (const [shape, group] of byShape) {\n    if (group.length < 2) {\n      continue;\n    }\n    for (const candidate of group.toSorted((left, right) => right.size - left.size)) {\n      if (consumed.some((ancestor) => isAncestor(ancestor, candidate.node))) {\n        continue;\n      }\n      counted.push(candidate);\n      consumed.push(candidate.node);\n      groupCounts.set(shape, (groupCounts.get(shape) ?? 0) + 1);\n      maxDuplicateBlockSize = Math.max(maxDuplicateBlockSize, candidate.size);\n    }\n  }\n  let duplicateBlockGroupCount = 0;\n  for (const count of groupCounts.values()) {\n    if (count >= 2) {\n      duplicateBlockCount += count - 1;\n      duplicateBlockGroupCount += 1;\n    }\n  }\n\n  return { duplicateBlockCount, duplicateBlockGroupCount, maxDuplicateBlockSize };\n}\n\n/** Serializes a subtree by node type only (ignoring identifiers and literals) and reports its node count. */\nfunction describeShape(\n  node: Parser.SyntaxNode,\n  cache: Map<number, { shape: string; size: number }>\n): { shape: string; size: number } {\n  const cached = cache.get(node.id);\n  if (cached) {\n    return cached;\n  }\n\n  let shape = node.type;\n  let size = 1;\n  if (node.namedChildCount > 0) {\n    const parts: string[] = [];\n    for (const child of node.namedChildren) {\n      const childShape = describeShape(child, cache);\n      parts.push(childShape.shape);\n      size += childShape.size;\n    }\n    shape = `${node.type}(${parts.join(',')})`;\n  }\n\n  const result = { shape, size };\n  cache.set(node.id, result);\n  return result;\n}\n\nfunction isAncestor(ancestor: Parser.SyntaxNode, node: Parser.SyntaxNode): boolean {\n  let current = node.parent;\n  while (current) {\n    if (current.id === ancestor.id) {\n      return true;\n    }\n    current = current.parent;\n  }\n  return false;\n}\n\nfunction measureLines(code: string, root: Parser.SyntaxNode): CodeMetrics['lines'] {\n  const sourceLines = code.length === 0 ? [] : code.split(/\\r\\n|\\n|\\r/);\n  const commentSpans = collectCommentSpans(root);\n  let blank = 0;\n  let comment = 0;\n\n  for (const [index, line] of sourceLines.entries()) {\n    if (line.trim() === '') {\n      blank += 1;\n      continue;\n    }\n\n    if (isCommentOnlyLine(line, index, commentSpans)) {\n      comment += 1;\n    }\n  }\n\n  return {\n    total: sourceLines.length,\n    code: sourceLines.length - blank - comment,\n    comment,\n    blank,\n  };\n}\n\nfunction collectCommentSpans(root: Parser.SyntaxNode): CommentSpan[] {\n  const spans: CommentSpan[] = [];\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (node.type === 'comment' || node.type === 'line_comment' || node.type === 'block_comment') {\n      for (let row = node.startPosition.row; row <= node.endPosition.row; row += 1) {\n        spans.push({\n          line: row,\n          startColumn: row === node.startPosition.row ? node.startPosition.column : 0,\n          endColumn: row === node.endPosition.row ? node.endPosition.column : Number.POSITIVE_INFINITY,\n        });\n      }\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return spans;\n}\n\nfunction isCommentOnlyLine(line: string, lineIndex: number, spans: CommentSpan[]): boolean {\n  const relevantSpans = spans.filter((span) => span.line === lineIndex);\n  if (relevantSpans.length === 0) {\n    return false;\n  }\n\n  const firstContentColumn = line.search(/\\S/);\n  const lastContentColumn = line.trimEnd().length;\n\n  return relevantSpans.some((span) => span.startColumn <= firstContentColumn && span.endColumn >= lastContentColumn);\n}\n\nfunction measureHalstead(root: Parser.SyntaxNode, code: string): HalsteadMetrics {\n  const operators = new Map<string, number>();\n  const operands = new Map<string, number>();\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (node.type === 'comment') {\n      return;\n    }\n\n    if (node.childCount === 0) {\n      const text = code.slice(node.startIndex, node.endIndex);\n      if (operatorTexts.has(text) || operatorTexts.has(node.type)) {\n        incrementCount(operators, text || node.type);\n      } else if (operandNodeTypes.has(node.type)) {\n        incrementCount(operands, text);\n      }\n      return;\n    }\n\n    if (operatorTexts.has(node.type)) {\n      incrementCount(operators, node.type);\n    }\n\n    for (const child of node.children) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n\n  const distinctOperators = operators.size;\n  const distinctOperands = operands.size;\n  const totalOperators = sum(operators.values());\n  const totalOperands = sum(operands.values());\n  const vocabulary = distinctOperators + distinctOperands;\n  const length = totalOperators + totalOperands;\n  const volume = vocabulary === 0 ? 0 : length * Math.log2(vocabulary);\n  const difficulty = distinctOperands === 0 ? 0 : (distinctOperators / 2) * (totalOperands / distinctOperands);\n  const effort = difficulty * volume;\n\n  return {\n    distinctOperators,\n    distinctOperands,\n    totalOperators,\n    totalOperands,\n    vocabulary,\n    length,\n    volume,\n    difficulty,\n    effort,\n    time: effort / 18,\n    bugs: volume / 3000,\n  };\n}\n\nfunction findFunctionName(node: Parser.SyntaxNode): string | undefined {\n  const wrappedName = findWrappedComponentName(node);\n  if (wrappedName) {\n    return wrappedName;\n  }\n\n  const nameNode = node.childForFieldName('name');\n  if (nameNode) {\n    return nameNode.text;\n  }\n\n  const parent = node.parent;\n  if (!parent) {\n    return undefined;\n  }\n\n  // A Rust closure bound to a simple `let` identifier (`let add = |x| ...;`) takes that identifier\n  // as its name, mirroring how JS arrow functions assigned to a variable are named, so calls to the\n  // binding resolve as intra-file edges.\n  if (node.type === 'closure_expression' && parent.type === 'let_declaration') {\n    const patternNode = parent.childForFieldName('pattern');\n    return patternNode?.type === 'identifier' ? patternNode.text : undefined;\n  }\n\n  const parentName = parent.childForFieldName('name');\n  return parentName?.text;\n}\n\nfunction findWrappedComponentName(node: Parser.SyntaxNode): string | undefined {\n  let current: Parser.SyntaxNode | undefined = node;\n  while (current) {\n    const argumentsNode: Parser.SyntaxNode | null = current.parent;\n    const callNode: Parser.SyntaxNode | null | undefined = argumentsNode?.parent;\n    if (argumentsNode?.type !== 'arguments' || callNode?.type !== 'call_expression') {\n      return undefined;\n    }\n\n    if (!isReactComponentWrapperCall(callNode)) {\n      return undefined;\n    }\n\n    const declaratorNode = callNode.parent;\n    if (declaratorNode?.type === 'variable_declarator') {\n      return declaratorNode.childForFieldName('name')?.text;\n    }\n\n    current = callNode;\n  }\n\n  return undefined;\n}\n\nfunction isReactComponentWrapperCall(node: Parser.SyntaxNode): boolean {\n  const calleeNode = node.childForFieldName('function') ?? node.namedChild(0);\n  return (\n    calleeNode?.text === 'memo' ||\n    calleeNode?.text === 'React.memo' ||\n    calleeNode?.text === 'forwardRef' ||\n    calleeNode?.text === 'React.forwardRef'\n  );\n}\n\nfunction isCallNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'call_expression' || node.type === 'call' || node.type === 'macro_invocation';\n}\n\nfunction findCalleeName(node: Parser.SyntaxNode): string | undefined {\n  // The `namedChild(0)` fallback covers Rust `macro_invocation` (whose callee is the `macro` field,\n  // not `function`), so macros resolve to their name. `findRightmostIdentifier` must be kept rather\n  // than reading `calleeNode.text`: member calls like `self.map.get(key)` must resolve to `get`, not\n  // the full `self.map.get`, so intra-file call-graph name matching stays correct.\n  const calleeNode = node.childForFieldName('function') ?? node.namedChild(0);\n  if (!calleeNode) {\n    return undefined;\n  }\n\n  return findRightmostIdentifier(calleeNode);\n}\n\nfunction findRightmostIdentifier(node: Parser.SyntaxNode): string | undefined {\n  if (\n    node.type === 'identifier' ||\n    node.type === 'property_identifier' ||\n    node.type === 'field_identifier' ||\n    node.type === 'attribute'\n  ) {\n    return node.text;\n  }\n\n  for (let index = node.namedChildCount - 1; index >= 0; index -= 1) {\n    const child = node.namedChild(index);\n    if (!child) {\n      continue;\n    }\n\n    const identifier = findRightmostIdentifier(child);\n    if (identifier) {\n      return identifier;\n    }\n  }\n\n  return undefined;\n}\n\nfunction isReactCreateElementCall(node: Parser.SyntaxNode): boolean {\n  if (!isCallNode(node)) {\n    return false;\n  }\n\n  const calleeNode = node.childForFieldName('function') ?? node.namedChild(0);\n  return calleeNode?.text === 'React.createElement' || calleeNode?.text === 'createElement';\n}\n\nfunction isImportNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'import_statement' ||\n    node.type === 'import_declaration' ||\n    node.type === 'import_from_statement' ||\n    node.type === 'import_spec' ||\n    node.type === 'import_spec_list' ||\n    node.type === 'use_declaration' ||\n    node.type === 'extern_crate_declaration'\n  );\n}\n\nfunction isImportSourceNode(node: Parser.SyntaxNode): boolean {\n  return (\n    isImportNode(node) || isDynamicImportNode(node) || (isExportNode(node) && node.childForFieldName('source') !== null)\n  );\n}\n\nfunction isDynamicImportNode(node: Parser.SyntaxNode): boolean {\n  if (!isCallNode(node)) {\n    return false;\n  }\n\n  const calleeNode = node.childForFieldName('function') ?? node.namedChild(0);\n  return calleeNode?.text === 'import';\n}\n\nfunction findImportSources(\n  node: Parser.SyntaxNode,\n  language: LanguageDefinition,\n  options: { expandPythonSubmodules: boolean }\n): string[] {\n  if (language.name === 'python') {\n    const pythonSources = findPythonImportSources(node, options);\n    if (pythonSources.length > 0) {\n      return pythonSources;\n    }\n  }\n\n  if (language.name === 'rust') {\n    return findRustImportSources(node);\n  }\n\n  if (isDynamicImportNode(node)) {\n    return findDynamicImportSources(node);\n  }\n\n  const sourceNode = node.childForFieldName('source') ?? findFirstStringNode(node);\n  return sourceNode ? [unquote(sourceNode.text)] : [];\n}\n\nfunction findDynamicImportSources(node: Parser.SyntaxNode): string[] {\n  const argumentsNode = node.childForFieldName('arguments');\n  const firstArgument = argumentsNode?.namedChild(0);\n  return firstArgument && isStringNode(firstArgument) ? [unquote(firstArgument.text)] : [];\n}\n\nfunction isRelativeImportSource(source: string, language: LanguageName): boolean {\n  if (source.startsWith('.') || source.startsWith('/')) {\n    return true;\n  }\n\n  // `crate`/`self`/`super` are local only in Rust; other languages may legitimately import a module\n  // literally named that, so the in-crate rule must not leak across languages.\n  return language === 'rust' && isRustLocalImportSource(source);\n}\n\n/** Rust in-crate imports address the module tree through `crate`, `self`, or `super`. */\nfunction isRustLocalImportSource(source: string): boolean {\n  return /^(?:crate|self|super)(?:::|$)/u.test(source);\n}\n\n/**\n * Extracts the module path(s) a Rust `use` declaration reaches into, dropping the imported leaf item(s).\n * Grouped imports are fully expanded so each imported item resolves to its own module, e.g.\n * `use std::{collections::HashMap, fmt};` yields `std::collections` and `std`, matching the single-item\n * forms `use std::collections::HashMap;` and `use std::fmt;`.\n */\nfunction findRustImportSources(node: Parser.SyntaxNode): string[] {\n  // `extern crate serde as s;` names the crate directly; the alias is irrelevant to the source.\n  if (node.type === 'extern_crate_declaration') {\n    const nameNode = node.childForFieldName('name');\n    return nameNode ? [normalizeImportSource(nameNode.text)] : [];\n  }\n\n  const argument = node.childForFieldName('argument');\n  return argument ? rustImportSources(argument, '') : [];\n}\n\n/** Resolves the module source(s) of a `use` tree node, given the module `prefix` accumulated from ancestors. */\nfunction rustImportSources(node: Parser.SyntaxNode, prefix: string): string[] {\n  switch (node.type) {\n    case 'use_list': {\n      return node.namedChildren.flatMap((child) => rustImportSources(child, prefix));\n    }\n    case 'scoped_use_list': {\n      const listNode = node.childForFieldName('list');\n      const nextPrefix = joinModulePath(prefix, rustPathText(node.childForFieldName('path')));\n      return listNode ? rustImportSources(listNode, nextPrefix) : withModulePrefix(nextPrefix);\n    }\n    case 'scoped_identifier': {\n      // Drop the leaf item: the source is the prefix plus this node's own `path` field.\n      return withModulePrefix(joinModulePath(prefix, rustPathText(node.childForFieldName('path'))));\n    }\n    case 'use_wildcard': {\n      // `use a::b::*;` imports from `a::b`; the wildcard has no `path` field, so its whole inner path counts.\n      return withModulePrefix(joinModulePath(prefix, rustPathText(node.namedChild(0))));\n    }\n    case 'use_as_clause': {\n      const pathNode = node.childForFieldName('path');\n      return pathNode ? rustImportSources(pathNode, prefix) : [];\n    }\n    case 'self': {\n      // `self` in a group (`use std::io::{self, Write};`) refers to the prefix module itself.\n      return withModulePrefix(prefix);\n    }\n    case 'identifier':\n    case 'crate':\n    case 'super': {\n      // A bare leaf item: at the top level (`use tokio;`) it is the module; inside a group its module is the prefix.\n      return withModulePrefix(prefix === '' ? normalizeImportSource(node.text) : prefix);\n    }\n    default: {\n      return [];\n    }\n  }\n}\n\nfunction rustPathText(node: Parser.SyntaxNode | null): string {\n  return node ? normalizeImportSource(node.text) : '';\n}\n\nfunction joinModulePath(prefix: string, segment: string): string {\n  if (!segment) {\n    return prefix;\n  }\n  return prefix ? `${prefix}::${segment}` : segment;\n}\n\nfunction withModulePrefix(source: string): string[] {\n  return source ? [source] : [];\n}\n\nfunction findPythonImportSources(node: Parser.SyntaxNode, options: { expandPythonSubmodules: boolean }): string[] {\n  if (node.type === 'import_from_statement') {\n    const moduleNode = node.childForFieldName('module_name');\n    if (!moduleNode) {\n      return [];\n    }\n\n    const moduleSource = normalizeImportSource(moduleNode.text);\n    const nameNodes = findChildrenByFieldName(node, 'name');\n    if (!options.expandPythonSubmodules || !moduleSource.startsWith('.')) {\n      return [moduleSource];\n    }\n    if (/^\\.+$/u.test(moduleSource) && nameNodes.length > 0) {\n      return nameNodes.flatMap(findPythonImportNames).map((name) => `${moduleSource}${name}`);\n    }\n    const submoduleSources = nameNodes.flatMap(findPythonImportNames).map((name) => `${moduleSource}.${name}`);\n    if (submoduleSources.length > 0) {\n      return [moduleSource, ...submoduleSources];\n    }\n    return [moduleSource];\n  }\n\n  if (node.type !== 'import_statement') {\n    return [];\n  }\n\n  return node.namedChildren\n    .map((child) => findPythonImportedModuleName(child))\n    .filter((source) => source !== undefined);\n}\n\nfunction findPythonImportNames(node: Parser.SyntaxNode): string[] {\n  if (node.type === 'aliased_import') {\n    const nameNode = node.childForFieldName('name');\n    return nameNode ? findPythonImportNames(nameNode) : [];\n  }\n\n  if (node.type === 'identifier') {\n    return [node.text];\n  }\n\n  if (node.type === 'dotted_name') {\n    return [normalizeImportSource(node.text)];\n  }\n\n  return node.namedChildren.flatMap(findPythonImportNames);\n}\n\nfunction findChildrenByFieldName(node: Parser.SyntaxNode, fieldName: string): Parser.SyntaxNode[] {\n  const children: Parser.SyntaxNode[] = [];\n  for (let index = 0; index < node.childCount; index += 1) {\n    const child = node.child(index);\n    if (child && node.fieldNameForChild(index) === fieldName) {\n      children.push(child);\n    }\n  }\n  return children;\n}\n\nfunction findPythonImportedModuleName(node: Parser.SyntaxNode): string | undefined {\n  if (node.type === 'dotted_name' || node.type === 'relative_import') {\n    return normalizeImportSource(node.text);\n  }\n\n  const nameNode = node.childForFieldName('name');\n  if (nameNode) {\n    return normalizeImportSource(nameNode.text);\n  }\n\n  for (const child of node.namedChildren) {\n    const source = findPythonImportedModuleName(child);\n    if (source) {\n      return source;\n    }\n  }\n\n  return undefined;\n}\n\nfunction normalizeImportSource(source: string): string {\n  return source.replaceAll(/\\s+/gu, '');\n}\n\nfunction findFirstStringNode(node: Parser.SyntaxNode): Parser.SyntaxNode | undefined {\n  if (isStringNode(node)) {\n    return node;\n  }\n\n  for (const child of node.namedChildren) {\n    const stringNode = findFirstStringNode(child);\n    if (stringNode) {\n      return stringNode;\n    }\n  }\n\n  return undefined;\n}\n\nfunction isStringNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'string' || node.type === 'string_literal' || node.type === 'interpreted_string_literal';\n}\n\nfunction unquote(value: string): string {\n  return value.replaceAll(/^['\"`]|['\"`]$/gu, '');\n}\n\nfunction isExportNode(node: Parser.SyntaxNode): boolean {\n  return node.type.startsWith('export') || node.type === 'public_field_definition';\n}\n\nfunction findRecursiveIndexes(graph: Map<number, Set<number>>): Set<number> {\n  const recursiveIndexes = new Set<number>();\n\n  for (const index of graph.keys()) {\n    if (canReach(index, index, graph, new Set())) {\n      recursiveIndexes.add(index);\n    }\n  }\n\n  return recursiveIndexes;\n}\n\nfunction canReach(start: number, target: number, graph: Map<number, Set<number>>, visited: Set<number>): boolean {\n  const callees = graph.get(start);\n  if (!callees) {\n    return false;\n  }\n\n  for (const callee of callees) {\n    if (callee === target) {\n      return true;\n    }\n\n    if (!visited.has(callee)) {\n      visited.add(callee);\n      if (canReach(callee, target, graph, visited)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\nfunction measureMaxCallDepth(graph: Map<number, Set<number>>): number {\n  let maxDepth = 0;\n  for (const index of graph.keys()) {\n    maxDepth = Math.max(maxDepth, measureCallDepth(index, graph, new Set()));\n  }\n  return maxDepth;\n}\n\nfunction measureCallDepth(index: number, graph: Map<number, Set<number>>, pathIndexes: Set<number>): number {\n  const callees = graph.get(index);\n  if (!callees || callees.size === 0 || pathIndexes.has(index)) {\n    return 0;\n  }\n\n  pathIndexes.add(index);\n  let maxDepth = 0;\n  for (const callee of callees) {\n    maxDepth = Math.max(maxDepth, 1 + measureCallDepth(callee, graph, new Set(pathIndexes)));\n  }\n  return maxDepth;\n}\n\nfunction intersectSets(left: Set<string>, right: Set<string>): Set<string> {\n  const intersection = new Set<string>();\n  for (const value of left) {\n    if (right.has(value)) {\n      intersection.add(value);\n    }\n  }\n  return intersection;\n}\n\nfunction calculateMaintainabilityIndex(volume: number, complexity: number, loc: number): number {\n  if (loc === 0) {\n    return 100;\n  }\n\n  const raw = 171 - 5.2 * Math.log(Math.max(volume, 1)) - 0.23 * complexity - 16.2 * Math.log(loc);\n  return Math.max(0, Math.min(100, (raw * 100) / 171));\n}\n\nfunction incrementCount(map: Map<string, number>, value: string): void {\n  map.set(value, (map.get(value) ?? 0) + 1);\n}\n\nfunction maxMetric(functions: FunctionMetrics[], key: 'cyclomaticComplexity' | 'cognitiveComplexity'): number {\n  return functions.length === 0 ? 0 : Math.max(...functions.map((fn) => fn[key]));\n}\n\nfunction maxMapValue(map: Map<unknown, number>): number {\n  let maximum = 0;\n  for (const value of map.values()) {\n    maximum = Math.max(maximum, value);\n  }\n  return maximum;\n}\n\nfunction sum(values: Iterable<number>): number {\n  let total = 0;\n  for (const value of values) {\n    total += value;\n  }\n  return total;\n}\n"],"names":["booleanOperators","Set","operatorTexts","operandNodeTypes","TreeMeasurer","registry","createLanguageRegistry","registerLanguage","language","this","set","name","alias","aliases","getSupportedLanguages","values","map","measure","code","options","get","Error","parser","Parser","setLanguage","parserLanguage","root","parse","undefined","bufferSize","length","rootNode","structuralMetrics","functions","analyses","node","index","complexity","measureComplexity","calls","callees","functionNodeTypes","callCount","visit","insideRoot","has","type","isCallNode","callee","calleeNode","childForFieldName","namedChild","findRightmostIdentifier","findCalleeName","add","child","namedChildren","collectCalls","findFunctionName","startLine","startPosition","row","startColumn","column","endLine","endPosition","returnsJsx","cyclomaticComplexity","cognitiveComplexity","parameterCount","countParameters","identifiers","collectIdentifiers","analyzeFunction","callGraph","indexesByName","Map","analysis","entries","filter","entry","mapUniqueFunctionIndexesByName","functionNames","keys","fanInByIndex","fanOutByIndex","graph","internalCallCount","allCallees","internalCalleeNames","internalCalleeIndexes","calleeIndex","size","recursiveIndexes","canReach","findRecursiveIndexes","metrics","uniqueCalleeCount","internalEdgeCount","sum","recursiveFunctionCount","maxFanIn","maxMapValue","maxFanOut","maxCallDepth","measureMaxCallDepth","measureCallGraph","fanIn","fanOut","recursive","coupling","measureCoupling","module","measureModule","cohesion","measureCohesion","syntaxFeatures","measureSyntaxFeatures","typeComplexity","measureTypeComplexity","measureStructuralMetrics","collectNodes","functionMetrics","globalComplexity","lines","sourceLines","split","commentSpans","spans","push","line","endColumn","Number","POSITIVE_INFINITY","collectCommentSpans","blank","comment","trim","isCommentOnlyLine","total","measureLines","halstead","operators","operands","childCount","text","slice","startIndex","endIndex","incrementCount","children","distinctOperators","distinctOperands","totalOperators","totalOperands","vocabulary","volume","Math","log2","difficulty","effort","time","bugs","measureHalstead","bytes","Buffer","byteLength","classCount","classNodeTypes","functionCount","maxCyclomaticComplexity","maxMetric","maxCognitiveComplexity","nestingDepth","duplication","measureDuplication","maintainabilityIndex","calculateMaintainabilityIndex","syntaxTree","includeSyntaxTree","toString","defaultMeasurer","measureCode","parametersNode","find","nesting","stopAtNestedFunctions","functionNodes","decisionNodes","decisionNodeTypes","nestingNodes","nestingNodeTypes","current","currentNesting","isDecision","isNesting","isNamed","isBooleanOperator","childNesting","max","nodeTypes","nodes","containsJsxExpression","containsReactCreateElementCall","getArrowFunctionBody","namedChildCount","containsNode","startsWith","calleeName","isArrayMappingCallee","some","containsReturnedJsxFunction","isJsxMappingCall","isReactCreateElementCall","predicate","body","containsOwnReturnNode","returnsJsxFromFunctionNode","importSources","visitImports","isImportSourceNode","source","findImportSources","expandPythonSubmodules","declarations","collectModuleDeclarations","exportedNames","insideSourcedExport","isExportSpecifierNode","nameNode","isDeclarationNameNode","findExportedName","isSourcedExport","isModuleExportNode","collectExportedNames","flatMap","collectTopLevelDeclarations","declaration","exported","isDeclarationContainer","isTopLevelDeclarationNode","receiverTypeNode","receiverType","replaceAll","replace","findGoMethodDeclarationName","findDeclarationName","declarationFromNode","importCount","exportCount","isImportNode","isDynamicImportNode","isExportNode","relativeImportCount","test","isRustLocalImportSource","isRelativeImportSource","importSourceCount","externalImportCount","assignmentCount","awaitExpressionCount","loopStatementCount","mutableBindingCount","returnStatementCount","throwStatementCount","tryStatementCount","isAssignmentNode","isAwaitNode","isLoopNode","firstChild","pattern","descendantsOfType","specifier","parent","hasRustMutableLetBinding","isMutableBindingNode","isReturnNode","isThrowNode","isTryNode","allIdentifiers","sharedIdentifiers","overlapTotal","pairCount","identifier","leftIndex","rightIndex","left","right","intersection","intersectSets","unionSize","averageFunctionIdentifierOverlap","sharedIdentifierCount","uniqueIdentifierCount","typeAnnotationCount","typeAliasCount","interfaceCount","genericParameterCount","unionTypeCount","intersectionTypeCount","conditionalTypeCount","typeAssertionCount","nonNullAssertionCount","satisfiesExpressionCount","duplicateBlockTypes","minDuplicateBlockSize","candidates","shapeCache","describeShape","shape","byShape","candidate","group","consumed","duplicateBlockCount","maxDuplicateBlockSize","groupCounts","toSorted","ancestor","isAncestor","duplicateBlockGroupCount","count","cache","cached","id","parts","childShape","join","result","lineIndex","relevantSpans","span","firstContentColumn","search","lastContentColumn","trimEnd","wrappedName","argumentsNode","callNode","isReactComponentWrapperCall","declaratorNode","findWrappedComponentName","patternNode","parentName","pythonSources","moduleNode","moduleSource","normalizeImportSource","nameNodes","fieldName","fieldNameForChild","findChildrenByFieldName","findPythonImportNames","submoduleSources","findPythonImportedModuleName","findPythonImportSources","argument","rustImportSources","findRustImportSources","firstArgument","isStringNode","unquote","findDynamicImportSources","sourceNode","findFirstStringNode","prefix","listNode","nextPrefix","joinModulePath","rustPathText","withModulePrefix","pathNode","segment","stringNode","value","start","target","visited","maxDepth","measureCallDepth","pathIndexes","loc","raw","log","min","key","fn","maximum"],"mappings":"mFAmBA,MAAMA,EAAmB,IAAIC,IAAI,CAAC,KAAM,KAAM,MAAO,OAC/CC,EAAgB,IAAID,IAAI,CAC5B,IACA,IACA,IACA,IACA,IACA,KACA,IACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,MACA,MACA,IACA,KACA,IACA,KACA,IACA,IACA,IACA,IACA,IACA,KACA,KACA,KACA,SACA,QACA,QACA,QACA,QACA,aAGIE,EAAmB,IAAIF,IAAI,CAC/B,aACA,sBACA,mBACA,kBACA,SACA,UACA,QACA,kBACA,gBACA,cACA,eACA,oBACA,SACA,iBACA,kBACA,oBACA,eACA,OACA,QACA,OACA,YACA,QAwCK,MAAMG,EACMC,SAAWC,IAE5BC,gBAAAA,CAAiBC,GACfC,KAAKJ,SAASK,IAAIF,EAASG,KAAMH,GACjC,IAAK,MAAMI,KAASJ,EAASK,SAAW,GACtCJ,KAAKJ,SAASK,IAAIE,EAAOJ,EAE7B,CAEAM,qBAAAA,GACE,MAAO,IAAI,IAAIb,IAAI,IAAIQ,KAAKJ,SAASU,UAAUC,IAAKR,GAAaA,EAASG,OAC5E,CAEAM,OAAAA,CAAQC,EAAcC,GACpB,MAAMX,EAAWC,KAAKJ,SAASe,IAAID,EAAQX,UAC3C,IAAKA,EACH,MAAM,IAAIa,MAAM,yBAAyBF,EAAQX,YAGnD,MAAMc,EAAS,IAAIC,EACnBD,EAAOE,YAAYhB,EAASiB,gBAC5B,MAGMC,EAHOJ,EAAOK,MAAMT,OAAMU,EAAW,CACzCC,WAAYX,EAAKY,OAAS,IAEVC,SAEZC,EA0CV,SACEN,EACAO,EACAzB,GAEA,MAAM0B,EAAWD,EAAUjB,IAAI,CAACmB,EAAMC,IA6BxC,SAAyBD,EAAyB3B,EAA8B4B,GAC9E,MAAMC,EAAaC,EAAkBH,EAAM3B,EAAU,GAAG,GAClD+B,EA0JR,SACEb,EACAlB,GAEA,MAAMgC,EAAU,IAAIvC,IACdwC,EAAoB,IAAIxC,IAAIO,EAASiC,mBAC3C,IAAIC,EAAY,EAEhB,SAASC,EAAMR,EAAyBS,GACtC,GAAKA,IAAcH,EAAkBI,IAAIV,EAAKW,MAA9C,CAIA,GAAIC,EAAWZ,GAAO,CACpBO,GAAa,EACb,MAAMM,EA+5BZ,SAAwBb,GAKtB,MAAMc,EAAad,EAAKe,kBAAkB,aAAef,EAAKgB,WAAW,GACzE,IAAKF,EACH,OAGF,OAAOG,EAAwBH,EACjC,CA16BqBI,CAAelB,GAC1Ba,GACFR,EAAQc,IAAIN,EAEhB,CAEA,IAAK,MAAMO,KAASpB,EAAKqB,cACvBb,EAAMY,GAAO,EAXf,CAaF,CAGA,OADAZ,EAAMjB,GAAM,GACL,CAAEgB,YAAWF,UACtB,CAtLgBiB,CAAatB,EAAM3B,GACjC,MAAO,CACL4B,QACAzB,KAAM+C,EAAiBvB,GACvBwB,UAAWxB,EAAKyB,cAAcC,IAAM,EACpCC,YAAa3B,EAAKyB,cAAcG,OAChCC,QAAS7B,EAAK8B,YAAYJ,IAAM,EAChCK,WAAYA,EAAW/B,EAAM3B,GAC7B2D,qBAAsB9B,EAAW8B,qBACjCC,oBAAqB/B,EAAW+B,oBAChC1B,UAAWH,EAAMG,UACjB2B,eAAgBC,EAAgBnC,GAChCK,QAASD,EAAMC,QACf+B,YAAaC,EAAmBrC,GAEpC,CA9CkDsC,CAAgBtC,EAAM3B,EAAU4B,IAC1EsC,EA6DR,SAA0BxC,GAMxB,MAAMyC,EAmDR,SAAwCzC,GACtC,MAAMyC,EAAgB,IAAIC,IAC1B,IAAK,MAAMC,KAAY3C,EAChB2C,EAASlE,MAIdgE,EAAcjE,IAAImE,EAASlE,KAAMgE,EAAc9B,IAAIgC,EAASlE,WAAQiB,EAAYiD,EAASzC,OAE3F,OAAO,IAAIwC,IAAI,IAAID,EAAcG,WAAWC,OAAQC,QAAkDpD,IAAboD,EAAM,IACjG,CA7DwBC,CAA+B/C,GAC/CgD,EAAgB,IAAIjF,IAAI0E,EAAcQ,QACtCC,EAAe,IAAIR,IACnBS,EAAgB,IAAIT,IACpBU,EAAQ,IAAIV,IAClB,IAAIlC,EAAY,EACZ6C,EAAoB,EACxB,MAAMC,EAAa,IAAIvF,IAEvB,IAAK,MAAM4E,KAAY3C,EAAU,CAC/BQ,GAAamC,EAASnC,UACtB,IAAK,MAAMM,KAAU6B,EAASrC,QAC5BgD,EAAWlC,IAAIN,GAGjB,MAAMyC,EAAsB,IAAIxF,IAAI,IAAI4E,EAASrC,SAASuC,OAAQ/B,GAAWkC,EAAcrC,IAAIG,KACzF0C,EAAwB,IAAIzF,IAClC,IAAK,MAAM+C,KAAUyC,EAAqB,CACxC,MAAME,EAAchB,EAAcvD,IAAI4B,QAClBpB,IAAhB+D,GACFD,EAAsBpC,IAAIqC,EAE9B,CAEAL,EAAM5E,IAAImE,EAASzC,MAAOsD,GAC1BL,EAAc3E,IAAImE,EAASzC,MAAOqD,EAAoBG,MACtDL,GAAqBE,EAAoBG,KACzC,IAAK,MAAMD,KAAeD,EACxBN,EAAa1E,IAAIiF,GAAcP,EAAahE,IAAIuE,IAAgB,GAAK,EAEzE,CAEA,MAAME,EA+yCR,SAA8BP,GAC5B,MAAMO,EAAmB,IAAI5F,IAE7B,IAAK,MAAMmC,KAASkD,EAAMH,OACpBW,EAAS1D,EAAOA,EAAOkD,EAAO,IAAIrF,MACpC4F,EAAiBvC,IAAIlB,GAIzB,OAAOyD,CACT,CAzzC2BE,CAAqBT,GAE9C,MAAO,CACLF,eACAC,gBACAQ,mBACAG,QAAS,CACPtD,YACAuD,kBAAmBT,EAAWI,KAC9BL,oBACAW,kBAAmBC,GAAI,IAAIb,EAAMvE,UAAUC,IAAKwB,GAAYA,EAAQoD,OACpEQ,uBAAwBP,EAAiBD,KACzCS,SAAUC,GAAYlB,GACtBmB,UAAWD,GAAYjB,GACvBmB,aAAcC,GAAoBnB,IAGxC,CApHoBoB,CAAiBxE,GAiBnC,MAAO,CACLD,UAjByBC,EAASlB,IAAK6D,IAAQ,CAC/ClE,KAAMkE,EAASlE,KACfgD,UAAWkB,EAASlB,UACpBG,YAAae,EAASf,YACtBE,QAASa,EAASb,QAClBE,WAAYW,EAASX,WACrBC,qBAAsBU,EAASV,qBAC/BC,oBAAqBS,EAAST,oBAC9B1B,UAAWmC,EAASnC,UACpBuD,kBAAmBpB,EAASrC,QAAQoD,KACpCe,MAAOjC,EAAUU,aAAahE,IAAIyD,EAASzC,QAAU,EACrDwE,OAAQlC,EAAUW,cAAcjE,IAAIyD,EAASzC,QAAU,EACvDiC,eAAgBQ,EAASR,eACzBwC,UAAWnC,EAAUmB,iBAAiBhD,IAAIgC,EAASzC,UAKnDsC,UAAWA,EAAUsB,QACrBc,SAAUC,EAAgBrF,EAAMlB,GAChCwG,OAAQC,EAAcvF,EAAMlB,GAC5B0G,SAAUC,EAAgBjF,GAC1BkF,eAAgBC,EAAsB3F,GACtC4F,eAAgBC,EAAsB7F,GAE1C,CA1E8B8F,CAAyB9F,EADjC+F,EAAa/F,EAAM,IAAIzB,IAAIO,EAASiC,oBACcjC,GAC9DkH,EAAkB1F,EAAkBC,UACpC0F,EAAmBrF,EAAkBZ,EAAMlB,EAAU,GAAG,GACxDoH,EA89BV,SAAsB1G,EAAcQ,GAClC,MAAMmG,EAA8B,IAAhB3G,EAAKY,OAAe,GAAKZ,EAAK4G,MAAM,cAClDC,EAuBR,SAA6BrG,GAC3B,MAAMsG,EAAuB,GAE7B,SAASrF,EAAMR,GACb,GAAkB,YAAdA,EAAKW,MAAoC,iBAAdX,EAAKW,MAAyC,kBAAdX,EAAKW,KAClE,IAAK,IAAIe,EAAM1B,EAAKyB,cAAcC,IAAKA,GAAO1B,EAAK8B,YAAYJ,IAAKA,GAAO,EACzEmE,EAAMC,KAAK,CACTC,KAAMrE,EACNC,YAAaD,IAAQ1B,EAAKyB,cAAcC,IAAM1B,EAAKyB,cAAcG,OAAS,EAC1EoE,UAAWtE,IAAQ1B,EAAK8B,YAAYJ,IAAM1B,EAAK8B,YAAYF,OAASqE,OAAOC,oBAKjF,IAAK,MAAM9E,KAASpB,EAAKqB,cACvBb,EAAMY,EAEV,CAGA,OADAZ,EAAMjB,GACCsG,CACT,CA5CuBM,CAAoB5G,GACzC,IAAI6G,EAAQ,EACRC,EAAU,EAEd,IAAK,MAAOpG,EAAO8F,KAASL,EAAY/C,UAClB,KAAhBoD,EAAKO,OAKLC,EAAkBR,EAAM9F,EAAO2F,KACjCS,GAAW,GALXD,GAAS,EASb,MAAO,CACLI,MAAOd,EAAY/F,OACnBZ,KAAM2G,EAAY/F,OAASyG,EAAQC,EACnCA,UACAD,QAEJ,CAr/BkBK,CAAa1H,EAAMQ,GAC3BmH,EAyhCV,SAAyBnH,EAAyBR,GAChD,MAAM4H,EAAY,IAAIlE,IAChBmE,EAAW,IAAInE,IAErB,SAASjC,EAAMR,GACb,GAAkB,YAAdA,EAAKW,KAAT,CAIA,GAAwB,IAApBX,EAAK6G,WAAkB,CACzB,MAAMC,EAAO/H,EAAKgI,MAAM/G,EAAKgH,WAAYhH,EAAKiH,UAM9C,YALIlJ,EAAc2C,IAAIoG,IAAS/I,EAAc2C,IAAIV,EAAKW,MACpDuG,GAAeP,EAAWG,GAAQ9G,EAAKW,MAC9B3C,EAAiB0C,IAAIV,EAAKW,OACnCuG,GAAeN,EAAUE,GAG7B,CAEI/I,EAAc2C,IAAIV,EAAKW,OACzBuG,GAAeP,EAAW3G,EAAKW,MAGjC,IAAK,MAAMS,KAASpB,EAAKmH,SACvB3G,EAAMY,EAjBR,CAmBF,CAEAZ,EAAMjB,GAEN,MAAM6H,EAAoBT,EAAUlD,KAC9B4D,EAAmBT,EAASnD,KAC5B6D,EAAiBtD,GAAI2C,EAAU/H,UAC/B2I,EAAgBvD,GAAI4C,EAAShI,UAC7B4I,EAAaJ,EAAoBC,EACjC1H,EAAS2H,EAAiBC,EAC1BE,EAAwB,IAAfD,EAAmB,EAAI7H,EAAS+H,KAAKC,KAAKH,GACnDI,EAAkC,IAArBP,EAAyB,EAAKD,EAAoB,GAAMG,EAAgBF,GACrFQ,EAASD,EAAaH,EAE5B,MAAO,CACLL,oBACAC,mBACAC,iBACAC,gBACAC,aACA7H,SACA8H,SACAG,aACAC,SACAC,KAAMD,EAAS,GACfE,KAAMN,EAAS,IAEnB,CA9kCqBO,CAAgBzI,EAAMR,GAEvC,MAAO,CACLV,SAAUA,EAASG,KACnByJ,MAAOC,OAAOC,WAAWpJ,GACzB0G,QACA3F,UAAWyF,EACX6C,WAAY9C,EAAa/F,EAAM,IAAIzB,IAAIO,EAASgK,iBAAiB1I,OACjE2I,cAAe/C,EAAgB5F,OAC/BqC,qBAAsBwD,EAAiBxD,qBACvCuG,wBAAyBC,GAAUjD,EAAiB,wBACpDtD,oBAAqBuD,EAAiBvD,oBACtCwG,uBAAwBD,GAAUjD,EAAiB,uBACnDmD,aAAclD,EAAiBkD,aAC/BnG,UAAW1C,EAAkB0C,UAC7BoC,SAAU9E,EAAkB8E,SAC5BE,OAAQhF,EAAkBgF,OAC1BE,SAAUlF,EAAkBkF,SAC5BE,eAAgBpF,EAAkBoF,eAClCE,eAAgBtF,EAAkBsF,eAClCwD,YAAaC,EAAmBrJ,GAChCmH,WACAmC,qBAAsBC,GACpBpC,EAASe,OACTjC,EAAiBxD,qBACjByD,EAAM1G,MAERgK,WAAY/J,EAAQgK,kBAAoBzJ,EAAK0J,gBAAaxJ,EAE9D,QAGWyJ,EAAkB,IAAIjL,EAE5B,SAASkL,EAAYpK,EAAcC,GACxC,OAAOkK,EAAgBpK,QAAQC,EAAMC,EACvC,CAwDA,SAASmD,EAAgBnC,GACvB,MAAMoJ,EACJpJ,EAAKe,kBAAkB,eACvBf,EAAKqB,cAAcgI,KAAMjI,GAAyB,sBAAfA,EAAMT,MAA+C,mBAAfS,EAAMT,MACjF,OAAKyI,EAKEA,EAAe/H,cAAcuB,OAAQxB,GAAyB,YAAfA,EAAMT,MAAqC,mBAAfS,EAAMT,MACrFhB,OALM,CAMX,CAuEA,SAASQ,EACPH,EACA3B,EACAiL,EACAC,GAEA,IAAIvH,EAAuB,EACvBC,EAAsB,EACtByG,EAAeY,EACnB,MAAME,EAAgB,IAAI1L,IAAIO,EAASiC,mBACjCmJ,EAAgB,IAAI3L,IAAIO,EAASqL,mBACjCC,EAAe,IAAI7L,IAAIO,EAASuL,kBAEtC,SAASpJ,EAAMqJ,EAA4BC,EAAwBrJ,GACjE,GAAI8I,GAAwCC,EAAc9I,IAAImJ,EAAQlJ,MACpE,OAGF,MAAMoJ,EAAaN,EAAc/I,IAAImJ,EAAQlJ,MACvCqJ,EAAYL,EAAajJ,IAAImJ,EAAQlJ,MAEvCoJ,IACF/H,GAAwB,EACxBC,GAAuB,EAAI6H,GAuBjC,SAA2B9J,GACzB,GAAIA,EAAKiK,QACP,OAAO,EAGT,OAAOpM,EAAiB6C,IAAIV,EAAK8G,KACnC,CA1BQoD,CAAkBL,KACpB7H,GAAwB,EACxBC,GAAuB,GAGzB,MAAMkI,EAAeH,EAAYF,EAAiB,EAAIA,EACtDpB,EAAehB,KAAK0C,IAAI1B,EAAcyB,GAEtC,IAAK,MAAM/I,KAASyI,EAAQ1C,SAC1B3G,EAAMY,EAAO+I,EAEjB,CAEA,IAAK,MAAM/I,KAASpB,EAAKmH,SACvB3G,EAAMY,EAAOkI,GAGf,MAAO,CAAEtH,uBAAsBC,sBAAqByG,eACtD,CAwCA,SAASrG,EAAmB9C,GAC1B,MAAM6C,EAAc,IAAItE,IAaxB,OAXA,SAAS0C,EAAMR,GACK,eAAdA,EAAKW,MAAuC,wBAAdX,EAAKW,MAAgD,qBAAdX,EAAKW,MAC5EyB,EAAYjB,IAAInB,EAAK8G,MAGvB,IAAK,MAAM1F,KAASpB,EAAKqB,cACvBb,EAAMY,EAEV,CAEAZ,CAAMjB,GACC6C,CACT,CAEA,SAASkD,EAAa/F,EAAyB8K,GAC7C,MAAMC,EAA6B,GAanC,OAXA,SAAS9J,EAAMR,GACTqK,EAAU3J,IAAIV,EAAKW,OACrB2J,EAAMxE,KAAK9F,GAGb,IAAK,MAAMoB,KAASpB,EAAKqB,cACvBb,EAAMY,EAEV,CAEAZ,CAAMjB,GACC+K,CACT,CAEA,SAASvI,EAAWxC,EAAyBlB,GAC3C,MAAMiC,EAAoB,IAAIxC,IAAIO,EAASiC,mBA4B3C,OA1BA,SAASE,EAAMR,EAAyBS,GACtC,IAAKA,GAAcH,EAAkBI,IAAIV,EAAKW,MAC5C,OAAO,EAGT,GAAkB,qBAAdX,EAAKW,KACP,OAAO4J,EAAsBvK,EAAMM,IAAsBkK,EAA+BxK,EAAMM,GAGhG,GACgB,mBAAdf,EAAKoB,MACLX,IAASyK,EAAqBlL,IAChB,oBAAdS,EAAKW,OACJL,EAAkBI,IAAIV,EAAKW,MAE5B,OAAO4J,EAAsBvK,EAAMM,IAAsBkK,EAA+BxK,EAAMM,GAGhG,IAAK,MAAMc,KAASpB,EAAKqB,cACvB,GAAIb,EAAMY,GAAO,GACf,OAAO,EAGX,OAAO,CACT,CAEOZ,CAAMjB,GAAM,EACrB,CAEA,SAASkL,EAAqBzK,GAC5B,OAAOA,EAAKe,kBAAkB,SAAWf,EAAKgB,WAAWhB,EAAK0K,gBAAkB,SAAMjL,CACxF,CAEA,SAAS8K,EAAsBhL,EAAyBe,GACtD,OAAOqK,EACLpL,EACAe,EACCN,GAASA,EAAKW,KAAKiK,WAAW,SAiCnC,SAA0B5K,EAAyBM,GACjD,IAAKM,EAAWZ,KAOlB,SAA8BA,GAC5B,IAAKA,EACH,OAAO,EAGT,MAAM6K,EAAa5J,EAAwBjB,GAC3C,MAAsB,QAAf6K,GAAuC,YAAfA,CACjC,CAd4BC,CAAqB9K,EAAKe,kBAAkB,aAAef,EAAKgB,WAAW,IACnG,OAAO,EAGT,OAAOhB,EAAKqB,cAAc0J,KAAM3J,GAAU4J,EAA4B5J,EAAOd,GAC/E,CAvC8C2K,CAAiBjL,EAAMM,GAErE,CAEA,SAASkK,EAA+BjL,EAAyBe,GAC/D,OAAOqK,EAAapL,EAAMe,EAAmB4K,EAC/C,CAEA,SAASP,EACPpL,EACAe,EACA6K,GAmBA,OAjBA,SAAS3K,EAAMR,EAAyBS,GACtC,IAAKA,GAAcH,EAAkBI,IAAIV,EAAKW,MAC5C,OAAO,EAGT,GAAIwK,EAAUnL,GACZ,OAAO,EAGT,IAAK,MAAMoB,KAASpB,EAAKqB,cACvB,GAAIb,EAAMY,GAAO,GACf,OAAO,EAGX,OAAO,CACT,CAEOZ,CAAMjB,GAAM,EACrB,CAmBA,SAASyL,EAA4BzL,EAAyBe,GAC5D,OAAIA,EAAkBI,IAAInB,EAAKoB,MAOjC,SAAoCpB,EAAyBe,GAC3D,MAAM8K,EAAqB,mBAAd7L,EAAKoB,KAA4B8J,EAAqBlL,QAAQE,EAC3E,GAAI2L,GAAsB,oBAAdA,EAAKzK,OAA+BL,EAAkBI,IAAI0K,EAAKzK,MACzE,OAAO4J,EAAsBa,EAAM9K,IAAsBkK,EAA+BY,EAAM9K,GAGhG,OAOF,SACEf,EACAe,EACA6K,GAEA,SAAS3K,EAAMR,EAAyBS,GACtC,IAAKA,GAAcH,EAAkBI,IAAIV,EAAKW,MAC5C,OAAO,EAGT,GAAkB,qBAAdX,EAAKW,MAA+BwK,EAAUnL,GAChD,OAAO,EAGT,IAAK,MAAMoB,KAASpB,EAAKqB,cACvB,GAAIb,EAAMY,GAAO,GACf,OAAO,EAGX,OAAO,CACT,CAEA,OAAOZ,EAAMjB,GAAM,EACrB,CA9BS8L,CACL9L,EACAe,EACCN,GAASuK,EAAsBvK,EAAMM,IAAsBkK,EAA+BxK,EAAMM,GAErG,CAjBWgL,CAA2B/L,EAAMe,GAGnCf,EAAK8B,cAAc0J,KAAM3J,GAAU4J,EAA4B5J,EAAOd,GAC/E,CAwCA,SAASwE,EAAcvF,EAAyBlB,GAC9C,MAAMkN,EAAgB,IAAIzN,IAgB1B,OAdA,SAAS0N,EAAaxL,GACpB,GAAIyL,EAAmBzL,GACrB,IAAK,MAAM0L,KAAUC,EAAkB3L,EAAM3B,EAAU,CAAEuN,wBAAwB,IAC/EL,EAAcpK,IAAIuK,GAItB,IAAK,MAAMtK,KAASpB,EAAKqB,cACvBmK,EAAapK,EAEjB,CAEAoK,CAAajM,GAEN,CACLsM,aAAcC,EAA0BvM,GACxCgM,cAAe,IAAIA,GAEvB,CAEA,SAASO,EAA0BvM,GACjC,MAAMwM,EA2FR,SAA8BxM,GAC5B,MAAMwM,EAAgB,IAAIjO,IAE1B,SAAS0C,EAAMR,EAAyBgM,GACtC,IAAKA,GAkBT,SAA+BhM,GAC7B,MAAqB,qBAAdA,EAAKW,MAA6C,qBAAdX,EAAKW,IAClD,CApBgCsL,CAAsBjM,GAAO,CACvD,MAAMxB,EAqBZ,SAA0BwB,GACxB,MAAMkM,EACJlM,EAAKe,kBAAkB,SAAWf,EAAKe,kBAAkB,UAAYf,EAAKqB,cAAcgI,KAAK8C,GAC/F,OAAOD,GAAYC,EAAsBD,GAAYA,EAASpF,UAAOrH,CACvE,CAzBmB2M,CAAiBpM,GAC1BxB,GACFuN,EAAc5K,IAAI3C,EAEtB,CAEA,MAAM6N,EACJL,GAAwBM,EAAmBtM,IAA8C,OAArCA,EAAKe,kBAAkB,UAC7E,IAAK,MAAMK,KAASpB,EAAKqB,cACvBb,EAAMY,EAAOiL,EAEjB,CAGA,OADA7L,EAAMjB,GAAM,GACLwM,CACT,CA/GwBQ,CAAqBhN,GAC3C,OAAOA,EAAK8B,cACTmL,QAASpL,GAAUqL,EAA4BrL,GAAO,IACtDvC,IAAK6N,GAAiBX,EAAcrL,IAAIgM,EAAYlO,MAAQ,IAAKkO,EAAaC,UAAU,GAASD,EACtG,CAEA,SAASD,EAA4BzM,EAAyB2M,GAC5D,OAAIL,EAAmBtM,GACdA,EAAKqB,cAAcmL,QAASpL,GAAUqL,EAA4BrL,GAAO,IAoCpF,SAAgCpB,GAC9B,MACgB,wBAAdA,EAAKW,MACS,yBAAdX,EAAKW,MACS,yBAAdX,EAAKW,MACS,qBAAdX,EAAKW,MACS,sBAAdX,EAAKW,MACS,oBAAdX,EAAKW,MACS,kBAAdX,EAAKW,IAET,CA3CMiM,CAAuB5M,GAClBA,EAAKqB,cAAcmL,QAASpL,GAAUqL,EAA4BrL,EAAOuL,IAMpF,SAA6B3M,EAAyB2M,GACpD,IAqCF,SAAmC3M,GACjC,MACgB,yBAAdA,EAAKW,MACS,wBAAdX,EAAKW,MACS,kBAAdX,EAAKW,MACS,uBAAdX,EAAKW,MACS,sBAAdX,EAAKW,MACS,qBAAdX,EAAKW,MACS,0BAAdX,EAAKW,MACS,2BAAdX,EAAKW,MACS,qBAAdX,EAAKW,MACS,cAAdX,EAAKW,MACS,eAAdX,EAAKW,MACS,aAAdX,EAAKW,MACS,wBAAdX,EAAKW,MACS,gBAAdX,EAAKW,MACS,cAAdX,EAAKW,MACS,eAAdX,EAAKW,MACS,eAAdX,EAAKW,MACS,cAAdX,EAAKW,MACS,eAAdX,EAAKW,MACS,gBAAdX,EAAKW,MACS,aAAdX,EAAKW,IAET,CA7DOkM,CAA0B7M,GAC7B,MAAO,GAGT,MAAMxB,EAIR,SAA6BwB,GAC3B,GAAkB,uBAAdA,EAAKW,KACP,OA8FJ,SAAqCX,GACnC,MAAMkM,EAAWlM,EAAKe,kBAAkB,QAClC+L,EAAmB9M,EAAKe,kBAAkB,aAAaM,cAAc,IAAIN,kBAAkB,QACjG,IAAKmL,IAAaC,EAAsBD,KAAcY,EACpD,OAAOZ,GAAYC,EAAsBD,GAAYA,EAASpF,UAAOrH,EAGvE,MAAO,GAGwBsN,EAHGD,EAAiBhG,KAI5CiG,EAAaC,WAAW,QAAS,IAAIC,QAAQ,QAAS,OAJDf,EAASpF,OAGvE,IAAiCiG,CAFjC,CAtGWG,CAA4BlN,GAGrC,MAAMkM,EAAWlM,EAAKe,kBAAkB,QACxC,GAAImL,EACF,OAAOC,EAAsBD,GAAYA,EAASpF,UAAOrH,EAG3D,OAAOO,EAAKqB,cAAcgI,KAAK8C,IAAwBrF,IACzD,CAfeqG,CAAoBnN,GACjC,OAAOxB,EAAO,CAAC,CAAEmO,WAAUnO,OAAMgD,UAAWxB,EAAKyB,cAAcC,IAAM,IAAO,EAC9E,CAVS0L,CAAoBpN,EAAM2M,EACnC,CAwBA,SAASL,EAAmBtM,GAC1B,MAAqB,qBAAdA,EAAKW,MAA6C,uBAAdX,EAAKW,IAClD,CAwCA,SAASwL,EAAsBnM,GAC7B,MACgB,eAAdA,EAAKW,MACS,oBAAdX,EAAKW,MACS,wBAAdX,EAAKW,MACS,qBAAdX,EAAKW,IAET,CAgDA,SAASiE,EAAgBrF,EAAyBlB,GAChD,MAAMkN,EAAgB,IAAIzN,IAC1B,IAAIuP,EAAc,EACdC,EAAc,GAElB,SAAS9M,EAAMR,GAKb,IAJIuN,EAAavN,IAASwN,EAAoBxN,MAC5CqN,GAAe,GAGb5B,EAAmBzL,GACrB,IAAK,MAAM0L,KAAUC,EAAkB3L,EAAM3B,EAAU,CAAEuN,wBAAwB,IAC/EL,EAAcpK,IAAIuK,GAIlB+B,EAAazN,KACfsN,GAAe,GAGjB,IAAK,MAAMlM,KAASpB,EAAKqB,cACvBb,EAAMY,EAEV,CAEAZ,CAAMjB,GAEN,MAAMmO,EAAsB,IAAInC,GAAe3I,OAAQ8I,GAkpBzD,SAAgCA,EAAgBrN,GAC9C,GAAIqN,EAAOd,WAAW,MAAQc,EAAOd,WAAW,KAC9C,OAAO,EAKT,MAAoB,SAAbvM,GAIT,SAAiCqN,GAC/B,MAAO,iCAAiCiC,KAAKjC,EAC/C,CANgCkC,CAAwBlC,EACxD,CAzpBImC,CAAuBnC,EAAQrN,EAASG,OACxCmB,OAEF,MAAO,CACL0N,cACAS,kBAAmBvC,EAAc9H,KACjCiK,sBACAK,oBAAqBxC,EAAc9H,KAAOiK,EAC1CJ,cAEJ,CAEA,SAASpI,EAAsB3F,GAC7B,MAAMsE,EAAgC,CACpCmK,gBAAiB,EACjBC,qBAAsB,EACtBC,mBAAoB,EACpBC,oBAAqB,EACrBC,qBAAsB,EACtBC,oBAAqB,EACrBC,kBAAmB,GAgCrB,OA7BA,SAAS9N,EAAMR,IAgCjB,SAA0BA,GACxB,MACgB,0BAAdA,EAAKW,MACS,oCAAdX,EAAKW,MACS,yBAAdX,EAAKW,MACS,eAAdX,EAAKW,MACS,yBAAdX,EAAKW,MACS,0BAAdX,EAAKW,MACS,6BAAdX,EAAKW,IAET,EAzCQ4N,CAAiBvO,KACnB6D,EAAQmK,iBAAmB,GA0CjC,SAAqBhO,GACnB,MAAqB,qBAAdA,EAAKW,MAA6C,UAAdX,EAAKW,IAClD,CA1CQ6N,CAAYxO,KACd6D,EAAQoK,sBAAwB,GA2CtC,SAAoBjO,GAClB,MACgB,kBAAdA,EAAKW,MACS,qBAAdX,EAAKW,MACS,oBAAdX,EAAKW,MACS,iBAAdX,EAAKW,MACS,mBAAdX,EAAKW,MACS,qBAAdX,EAAKW,MACS,oBAAdX,EAAKW,IAET,CAnDQ8N,CAAWzO,KACb6D,EAAQqK,oBAAsB,GAoDpC,SAA8BlO,GAC5B,MACiB,wBAAdA,EAAKW,MAA4D,QAA1BX,EAAK0O,YAAY5H,MAC1C,yBAAd9G,EAAKW,MAA6D,QAA1BX,EAAK0O,YAAY5H,MAC5C,oBAAd9G,EAAKW,MACU,oBAAdX,EAAKW,MAWV,SAAkCX,GAChC,GAAIA,EAAKmH,SAAS4D,KAAM3J,GAAyB,sBAAfA,EAAMT,MACtC,OAAO,EAGT,MAAMgO,EAAU3O,EAAKe,kBAAkB,WACvC,IAAK4N,EACH,OAAO,EAGT,OAAOA,EACJC,kBAAkB,qBAClB7D,KAAM8D,GAAyC,sBAA3BA,EAAUC,QAAQnO,KAC3C,CAxBwCoO,CAAyB/O,EAEjE,CAzDQgP,CAAqBhP,KACvB6D,EAAQsK,qBAAuB,GAgFrC,SAAsBnO,GACpB,MAAqB,qBAAdA,EAAKW,MAA6C,sBAAdX,EAAKW,IAClD,CAhFQsO,CAAajP,KACf6D,EAAQuK,sBAAwB,GAiFtC,SAAqBpO,GACnB,MAAqB,oBAAdA,EAAKW,MAA4C,oBAAdX,EAAKW,IACjD,CAjFQuO,CAAYlP,KACd6D,EAAQwK,qBAAuB,GAkFrC,SAAmBrO,GACjB,MAAqB,kBAAdA,EAAKW,IACd,CAlFQwO,CAAUnP,KACZ6D,EAAQyK,mBAAqB,GAG/B,IAAK,MAAMlN,KAASpB,EAAKqB,cACvBb,EAAMY,EAEV,CAEAZ,CAAMjB,GACCsE,CACT,CAyEA,SAASmB,EAAgBjF,GACvB,MAAMqP,EAAiB,IAAItR,IACrBuR,EAAoB,IAAIvR,IAC9B,IAAIwR,EAAe,EACfC,EAAY,EAEhB,IAAK,MAAM7M,KAAY3C,EACrB,IAAK,MAAMyP,KAAc9M,EAASN,YAChCgN,EAAejO,IAAIqO,GAIvB,IAAK,IAAIC,EAAY,EAAGA,EAAY1P,EAASJ,OAAQ8P,GAAa,EAChE,IAAK,IAAIC,EAAaD,EAAY,EAAGC,EAAa3P,EAASJ,OAAQ+P,GAAc,EAAG,CAClF,MAAMC,EAAO5P,EAAS0P,GAChBG,EAAQ7P,EAAS2P,GACvB,IAAKC,IAASC,EACZ,SAGF,MAAMC,EAAeC,GAAcH,EAAKvN,YAAawN,EAAMxN,aACrD2N,EAAY,IAAIjS,IAAI,IAAI6R,EAAKvN,eAAgBwN,EAAMxN,cAAcqB,KACvE,IAAK,MAAM+L,KAAcK,EACvBR,EAAkBlO,IAAIqO,GAExBF,GAA8B,IAAdS,EAAkB,EAAIF,EAAapM,KAAOsM,EAC1DR,GAAa,CACf,CAGF,MAAO,CACLS,iCAAgD,IAAdT,EAAkB,EAAID,EAAeC,EACvEU,sBAAuBZ,EAAkB5L,KACzCyM,sBAAuBd,EAAe3L,KAE1C,CAEA,SAAS2B,EAAsB7F,GAC7B,MAAMsE,EAAiC,CACrCsM,oBAAqB,EACrBC,eAAgB,EAChBC,eAAgB,EAChBC,sBAAuB,EACvBC,eAAgB,EAChBC,sBAAuB,EACvBC,qBAAsB,EACtBC,mBAAoB,EACpBC,sBAAuB,EACvBC,yBAA0B,GAuD5B,OApDA,SAASpQ,EAAMR,GACb,OAAQA,EAAKW,MACX,IAAK,kBACHkD,EAAQsM,qBAAuB,EAC/B,MAEF,IAAK,yBACHtM,EAAQuM,gBAAkB,EAC1B,MAEF,IAAK,wBACHvM,EAAQwM,gBAAkB,EAC1B,MAEF,IAAK,kBACL,IAAK,iBACHxM,EAAQyM,uBAAuC,mBAAdtQ,EAAKW,KAA4B,EAAI,EACtE,MAEF,IAAK,aACHkD,EAAQ0M,gBAAkB,EAC1B,MAEF,IAAK,oBACH1M,EAAQ2M,uBAAyB,EACjC,MAEF,IAAK,mBACH3M,EAAQ4M,sBAAwB,EAChC,MAEF,IAAK,gBACL,IAAK,iBACH5M,EAAQ6M,oBAAsB,EAC9B,MAEF,IAAK,sBACH7M,EAAQ8M,uBAAyB,EACjC,MAEF,IAAK,uBACH9M,EAAQ+M,0BAA4B,EAKxC,IAAK,MAAMxP,KAASpB,EAAKqB,cACvBb,EAAMY,EAEV,CAEAZ,CAAMjB,GACCsE,CACT,CAEA,MAAMgN,EAAsB,IAAI/S,IAAI,CAClC,kBACA,QACA,eACA,gBACA,mBACA,kBACA,eACA,gBACA,iBACA,mBACA,cACA,cACA,kBACA,YACA,gBACA,eACA,iBACA,cACA,uBACA,mBACA,oBACA,gBACA,iBACA,mBACA,kBACA,mBACA,cACA,6BAIIgT,EAAwB,GAc9B,SAASlI,EAAmBrJ,GAC1B,MAAMwR,EAAmC,GACnCC,EAAa,IAAIvO,KAEvB,SAASjC,EAAMR,GACb,GAAI6Q,EAAoBnQ,IAAIV,EAAKW,MAAO,CACtC,MAAM8C,KAAEA,GAASwN,EAAcjR,EAAMgR,GACrC,GAAIvN,GAAQqN,EAAuB,CACjC,MAAMI,MAAEA,GAAUD,EAAcjR,EAAMgR,GACtCD,EAAWjL,KAAK,CAAE9F,OAAMkR,QAAOzN,QACjC,CACF,CACA,IAAK,MAAMrC,KAASpB,EAAKqB,cACvBb,EAAMY,EAEV,CACAZ,CAAMjB,GAEN,MAAM4R,EAAU,IAAI1O,IACpB,IAAK,MAAM2O,KAAaL,EAAY,CAClC,MAAMM,EAAQF,EAAQlS,IAAImS,EAAUF,QAAU,GAC9CG,EAAMvL,KAAKsL,GACXD,EAAQ5S,IAAI6S,EAAUF,MAAOG,EAC/B,CAIA,MAAMC,EAAgC,GACtC,IAAIC,EAAsB,EACtBC,EAAwB,EAC5B,MAAMC,EAAc,IAAIhP,IACxB,IAAK,MAAOyO,EAAOG,KAAUF,EAC3B,KAAIE,EAAM1R,OAAS,GAGnB,IAAK,MAAMyR,KAAaC,EAAMK,SAAS,CAAC/B,EAAMC,IAAUA,EAAMnM,KAAOkM,EAAKlM,MACpE6N,EAASvG,KAAM4G,GAAaC,EAAWD,EAAUP,EAAUpR,SAI/DsR,EAASxL,KAAKsL,EAAUpR,MACxByR,EAAYlT,IAAI2S,GAAQO,EAAYxS,IAAIiS,IAAU,GAAK,GACvDM,EAAwB9J,KAAK0C,IAAIoH,EAAuBJ,EAAU3N,OAGtE,IAAIoO,EAA2B,EAC/B,IAAK,MAAMC,KAASL,EAAY7S,SAC1BkT,GAAS,IACXP,GAAuBO,EAAQ,EAC/BD,GAA4B,GAIhC,MAAO,CAAEN,sBAAqBM,2BAA0BL,wBAC1D,CAGA,SAASP,EACPjR,EACA+R,GAEA,MAAMC,EAASD,EAAM9S,IAAIe,EAAKiS,IAC9B,GAAID,EACF,OAAOA,EAGT,IAAId,EAAQlR,EAAKW,KACb8C,EAAO,EACX,GAAIzD,EAAK0K,gBAAkB,EAAG,CAC5B,MAAMwH,EAAkB,GACxB,IAAK,MAAM9Q,KAASpB,EAAKqB,cAAe,CACtC,MAAM8Q,EAAalB,EAAc7P,EAAO2Q,GACxCG,EAAMpM,KAAKqM,EAAWjB,OACtBzN,GAAQ0O,EAAW1O,IACrB,CACAyN,EAAQ,GAAGlR,EAAKW,QAAQuR,EAAME,KAAK,OACrC,CAEA,MAAMC,EAAS,CAAEnB,QAAOzN,QAExB,OADAsO,EAAMxT,IAAIyB,EAAKiS,GAAII,GACZA,CACT,CAEA,SAAST,EAAWD,EAA6B3R,GAC/C,IAAI6J,EAAU7J,EAAK8O,OACnB,KAAOjF,GAAS,CACd,GAAIA,EAAQoI,KAAON,EAASM,GAC1B,OAAO,EAETpI,EAAUA,EAAQiF,MACpB,CACA,OAAO,CACT,CAkDA,SAASvI,EAAkBR,EAAcuM,EAAmBzM,GAC1D,MAAM0M,EAAgB1M,EAAMjD,OAAQ4P,GAASA,EAAKzM,OAASuM,GAC3D,GAA6B,IAAzBC,EAAc5S,OAChB,OAAO,EAGT,MAAM8S,EAAqB1M,EAAK2M,OAAO,MACjCC,EAAoB5M,EAAK6M,UAAUjT,OAEzC,OAAO4S,EAAcxH,KAAMyH,GAASA,EAAK7Q,aAAe8Q,GAAsBD,EAAKxM,WAAa2M,EAClG,CAyDA,SAASpR,EAAiBvB,GACxB,MAAM6S,EA2BR,SAAkC7S,GAChC,IAAI6J,EAAyC7J,EAC7C,KAAO6J,GAAS,CACd,MAAMiJ,EAA0CjJ,EAAQiF,OAClDiE,EAAiDD,GAAehE,OACtE,GAA4B,cAAxBgE,GAAenS,MAA2C,oBAAnBoS,GAAUpS,KACnD,OAGF,IAAKqS,EAA4BD,GAC/B,OAGF,MAAME,EAAiBF,EAASjE,OAChC,GAA6B,wBAAzBmE,GAAgBtS,KAClB,OAAOsS,EAAelS,kBAAkB,SAAS+F,KAGnD+C,EAAUkJ,CACZ,CAEA,MACF,CAjDsBG,CAAyBlT,GAC7C,GAAI6S,EACF,OAAOA,EAGT,MAAM3G,EAAWlM,EAAKe,kBAAkB,QACxC,GAAImL,EACF,OAAOA,EAASpF,KAGlB,MAAMgI,EAAS9O,EAAK8O,OACpB,IAAKA,EACH,OAMF,GAAkB,uBAAd9O,EAAKW,MAAiD,oBAAhBmO,EAAOnO,KAA4B,CAC3E,MAAMwS,EAAcrE,EAAO/N,kBAAkB,WAC7C,MAA6B,eAAtBoS,GAAaxS,KAAwBwS,EAAYrM,UAAOrH,CACjE,CAEA,MAAM2T,EAAatE,EAAO/N,kBAAkB,QAC5C,OAAOqS,GAAYtM,IACrB,CA0BA,SAASkM,EAA4BhT,GACnC,MAAMc,EAAad,EAAKe,kBAAkB,aAAef,EAAKgB,WAAW,GACzE,MACuB,SAArBF,GAAYgG,MACS,eAArBhG,GAAYgG,MACS,eAArBhG,GAAYgG,MACS,qBAArBhG,GAAYgG,IAEhB,CAEA,SAASlG,EAAWZ,GAClB,MAAqB,oBAAdA,EAAKW,MAA4C,SAAdX,EAAKW,MAAiC,qBAAdX,EAAKW,IACzE,CAeA,SAASM,EAAwBjB,GAC/B,GACgB,eAAdA,EAAKW,MACS,wBAAdX,EAAKW,MACS,qBAAdX,EAAKW,MACS,cAAdX,EAAKW,KAEL,OAAOX,EAAK8G,KAGd,IAAK,IAAI7G,EAAQD,EAAK0K,gBAAkB,EAAGzK,GAAS,EAAGA,GAAS,EAAG,CACjE,MAAMmB,EAAQpB,EAAKgB,WAAWf,GAC9B,IAAKmB,EACH,SAGF,MAAMoO,EAAavO,EAAwBG,GAC3C,GAAIoO,EACF,OAAOA,CAEX,CAGF,CAEA,SAAStE,EAAyBlL,GAChC,IAAKY,EAAWZ,GACd,OAAO,EAGT,MAAMc,EAAad,EAAKe,kBAAkB,aAAef,EAAKgB,WAAW,GACzE,MAA4B,wBAArBF,GAAYgG,MAAuD,kBAArBhG,GAAYgG,IACnE,CAEA,SAASyG,EAAavN,GACpB,MACgB,qBAAdA,EAAKW,MACS,uBAAdX,EAAKW,MACS,0BAAdX,EAAKW,MACS,gBAAdX,EAAKW,MACS,qBAAdX,EAAKW,MACS,oBAAdX,EAAKW,MACS,6BAAdX,EAAKW,IAET,CAEA,SAAS8K,EAAmBzL,GAC1B,OACEuN,EAAavN,IAASwN,EAAoBxN,IAAUyN,EAAazN,IAA8C,OAArCA,EAAKe,kBAAkB,SAErG,CAEA,SAASyM,EAAoBxN,GAC3B,IAAKY,EAAWZ,GACd,OAAO,EAGT,MAAMc,EAAad,EAAKe,kBAAkB,aAAef,EAAKgB,WAAW,GACzE,MAA4B,WAArBF,GAAYgG,IACrB,CAEA,SAAS6E,EACP3L,EACA3B,EACAW,GAEA,GAAsB,WAAlBX,EAASG,KAAmB,CAC9B,MAAM6U,EA8GV,SAAiCrT,EAAyBhB,GACxD,GAAkB,0BAAdgB,EAAKW,KAAkC,CACzC,MAAM2S,EAAatT,EAAKe,kBAAkB,eAC1C,IAAKuS,EACH,MAAO,GAGT,MAAMC,EAAeC,EAAsBF,EAAWxM,MAChD2M,EAwCV,SAAiCzT,EAAyB0T,GACxD,MAAMvM,EAAgC,GACtC,IAAK,IAAIlH,EAAQ,EAAGA,EAAQD,EAAK6G,WAAY5G,GAAS,EAAG,CACvD,MAAMmB,EAAQpB,EAAKoB,MAAMnB,GACrBmB,GAASpB,EAAK2T,kBAAkB1T,KAAWyT,GAC7CvM,EAASrB,KAAK1E,EAElB,CACA,OAAO+F,CACT,CAjDsByM,CAAwB5T,EAAM,QAChD,IAAKhB,EAAQ4M,yBAA2B2H,EAAa3I,WAAW,KAC9D,MAAO,CAAC2I,GAEV,GAAI,SAAS5F,KAAK4F,IAAiBE,EAAU9T,OAAS,EACpD,OAAO8T,EAAUjH,QAAQqH,GAAuBhV,IAAKL,GAAS,GAAG+U,IAAe/U,KAElF,MAAMsV,EAAmBL,EAAUjH,QAAQqH,GAAuBhV,IAAKL,GAAS,GAAG+U,KAAgB/U,KACnG,OAAIsV,EAAiBnU,OAAS,EACrB,CAAC4T,KAAiBO,GAEpB,CAACP,EACV,CAEA,GAAkB,qBAAdvT,EAAKW,KACP,MAAO,GAGT,OAAOX,EAAKqB,cACTxC,IAAKuC,GAAU2S,EAA6B3S,IAC5CwB,OAAQ8I,QAAsBjM,IAAXiM,EACxB,CA3I0BsI,CAAwBhU,EAAMhB,GACpD,GAAIqU,EAAc1T,OAAS,EACzB,OAAO0T,CAEX,CAEA,GAAsB,SAAlBhV,EAASG,KACX,OAsCJ,SAA+BwB,GAE7B,GAAkB,6BAAdA,EAAKW,KAAqC,CAC5C,MAAMuL,EAAWlM,EAAKe,kBAAkB,QACxC,OAAOmL,EAAW,CAACsH,EAAsBtH,EAASpF,OAAS,EAC7D,CAEA,MAAMmN,EAAWjU,EAAKe,kBAAkB,YACxC,OAAOkT,EAAWC,EAAkBD,EAAU,IAAM,EACtD,CA/CWE,CAAsBnU,GAG/B,GAAIwN,EAAoBxN,GACtB,OAOJ,SAAkCA,GAChC,MAAM8S,EAAgB9S,EAAKe,kBAAkB,aACvCqT,EAAgBtB,GAAe9R,WAAW,GAChD,OAAOoT,GAAiBC,EAAaD,GAAiB,CAACE,EAAQF,EAActN,OAAS,EACxF,CAXWyN,CAAyBvU,GAGlC,MAAMwU,EAAaxU,EAAKe,kBAAkB,WAAa0T,EAAoBzU,GAC3E,OAAOwU,EAAa,CAACF,EAAQE,EAAW1N,OAAS,EACnD,CAyCA,SAASoN,EAAkBlU,EAAyB0U,GAClD,OAAQ1U,EAAKW,MACX,IAAK,WACH,OAAOX,EAAKqB,cAAcmL,QAASpL,GAAU8S,EAAkB9S,EAAOsT,IAExE,IAAK,kBAAmB,CACtB,MAAMC,EAAW3U,EAAKe,kBAAkB,QAClC6T,EAAaC,EAAeH,EAAQI,EAAa9U,EAAKe,kBAAkB,UAC9E,OAAO4T,EAAWT,EAAkBS,EAAUC,GAAcG,EAAiBH,EAC/E,CACA,IAAK,oBAEH,OAAOG,EAAiBF,EAAeH,EAAQI,EAAa9U,EAAKe,kBAAkB,WAErF,IAAK,eAEH,OAAOgU,EAAiBF,EAAeH,EAAQI,EAAa9U,EAAKgB,WAAW,MAE9E,IAAK,gBAAiB,CACpB,MAAMgU,EAAWhV,EAAKe,kBAAkB,QACxC,OAAOiU,EAAWd,EAAkBc,EAAUN,GAAU,EAC1D,CACA,IAAK,OAEH,OAAOK,EAAiBL,GAE1B,IAAK,aACL,IAAK,QACL,IAAK,QAEH,OAAOK,EAA4B,KAAXL,EAAgBlB,EAAsBxT,EAAK8G,MAAQ4N,GAE7E,QACE,MAAO,GAGb,CAEA,SAASI,EAAa9U,GACpB,OAAOA,EAAOwT,EAAsBxT,EAAK8G,MAAQ,EACnD,CAEA,SAAS+N,EAAeH,EAAgBO,GACtC,OAAKA,EAGEP,EAAS,GAAGA,MAAWO,IAAYA,EAFjCP,CAGX,CAEA,SAASK,EAAiBrJ,GACxB,OAAOA,EAAS,CAACA,GAAU,EAC7B,CAiCA,SAASmI,EAAsB7T,GAC7B,GAAkB,mBAAdA,EAAKW,KAA2B,CAClC,MAAMuL,EAAWlM,EAAKe,kBAAkB,QACxC,OAAOmL,EAAW2H,EAAsB3H,GAAY,EACtD,CAEA,MAAkB,eAAdlM,EAAKW,KACA,CAACX,EAAK8G,MAGG,gBAAd9G,EAAKW,KACA,CAAC6S,EAAsBxT,EAAK8G,OAG9B9G,EAAKqB,cAAcmL,QAAQqH,EACpC,CAaA,SAASE,EAA6B/T,GACpC,GAAkB,gBAAdA,EAAKW,MAAwC,oBAAdX,EAAKW,KACtC,OAAO6S,EAAsBxT,EAAK8G,MAGpC,MAAMoF,EAAWlM,EAAKe,kBAAkB,QACxC,GAAImL,EACF,OAAOsH,EAAsBtH,EAASpF,MAGxC,IAAK,MAAM1F,KAASpB,EAAKqB,cAAe,CACtC,MAAMqK,EAASqI,EAA6B3S,GAC5C,GAAIsK,EACF,OAAOA,CAEX,CAGF,CAEA,SAAS8H,EAAsB9H,GAC7B,OAAOA,EAAOsB,WAAW,QAAS,GACpC,CAEA,SAASyH,EAAoBzU,GAC3B,GAAIqU,EAAarU,GACf,OAAOA,EAGT,IAAK,MAAMoB,KAASpB,EAAKqB,cAAe,CACtC,MAAM6T,EAAaT,EAAoBrT,GACvC,GAAI8T,EACF,OAAOA,CAEX,CAGF,CAEA,SAASb,EAAarU,GACpB,MAAqB,WAAdA,EAAKW,MAAmC,mBAAdX,EAAKW,MAA2C,+BAAdX,EAAKW,IAC1E,CAEA,SAAS2T,EAAQa,GACf,OAAOA,EAAMnI,WAAW,kBAAmB,GAC7C,CAEA,SAASS,EAAazN,GACpB,OAAOA,EAAKW,KAAKiK,WAAW,WAA2B,4BAAd5K,EAAKW,IAChD,CAcA,SAASgD,EAASyR,EAAeC,EAAgBlS,EAAiCmS,GAChF,MAAMjV,EAAU8C,EAAMlE,IAAImW,GAC1B,IAAK/U,EACH,OAAO,EAGT,IAAK,MAAMQ,KAAUR,EAAS,CAC5B,GAAIQ,IAAWwU,EACb,OAAO,EAGT,IAAKC,EAAQ5U,IAAIG,KACfyU,EAAQnU,IAAIN,GACR8C,EAAS9C,EAAQwU,EAAQlS,EAAOmS,IAClC,OAAO,CAGb,CAEA,OAAO,CACT,CAEA,SAAShR,GAAoBnB,GAC3B,IAAIoS,EAAW,EACf,IAAK,MAAMtV,KAASkD,EAAMH,OACxBuS,EAAW7N,KAAK0C,IAAImL,EAAUC,GAAiBvV,EAAOkD,EAAO,IAAIrF,MAEnE,OAAOyX,CACT,CAEA,SAASC,GAAiBvV,EAAekD,EAAiCsS,GACxE,MAAMpV,EAAU8C,EAAMlE,IAAIgB,GAC1B,IAAKI,GAA4B,IAAjBA,EAAQoD,MAAcgS,EAAY/U,IAAIT,GACpD,OAAO,EAGTwV,EAAYtU,IAAIlB,GAChB,IAAIsV,EAAW,EACf,IAAK,MAAM1U,KAAUR,EACnBkV,EAAW7N,KAAK0C,IAAImL,EAAU,EAAIC,GAAiB3U,EAAQsC,EAAO,IAAIrF,IAAI2X,KAE5E,OAAOF,CACT,CAEA,SAASzF,GAAcH,EAAmBC,GACxC,MAAMC,EAAe,IAAI/R,IACzB,IAAK,MAAMqX,KAASxF,EACdC,EAAMlP,IAAIyU,IACZtF,EAAa1O,IAAIgU,GAGrB,OAAOtF,CACT,CAEA,SAAS/G,GAA8BrB,EAAgBvH,EAAoBwV,GACzE,GAAY,IAARA,EACF,OAAO,IAGT,MAAMC,EAAM,IAAM,IAAMjO,KAAKkO,IAAIlO,KAAK0C,IAAI3C,EAAQ,IAAM,IAAOvH,EAAa,KAAOwH,KAAKkO,IAAIF,GAC5F,OAAOhO,KAAK0C,IAAI,EAAG1C,KAAKmO,IAAI,IAAY,IAANF,EAAa,KACjD,CAEA,SAASzO,GAAerI,EAA0BsW,GAChDtW,EAAIN,IAAI4W,GAAQtW,EAAII,IAAIkW,IAAU,GAAK,EACzC,CAEA,SAAS3M,GAAU1I,EAA8BgW,GAC/C,OAA4B,IAArBhW,EAAUH,OAAe,EAAI+H,KAAK0C,OAAOtK,EAAUjB,IAAKkX,GAAOA,EAAGD,IAC3E,CAEA,SAAS3R,GAAYtF,GACnB,IAAImX,EAAU,EACd,IAAK,MAAMb,KAAStW,EAAID,SACtBoX,EAAUtO,KAAK0C,IAAI4L,EAASb,GAE9B,OAAOa,CACT,CAEA,SAAShS,GAAIpF,GACX,IAAI4H,EAAQ,EACZ,IAAK,MAAM2O,KAASvW,EAClB4H,GAAS2O,EAEX,OAAO3O,CACT"}
+{"version":3,"file":"metrics.js","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["import Parser from 'tree-sitter';\nimport { measureDuplication } from './duplication.js';\nimport { createLanguageRegistry } from './languages.js';\nimport type {\n  CallGraphMetrics,\n  CodeMetrics,\n  CohesionMetrics,\n  CouplingMetrics,\n  DeclarationMetrics,\n  FunctionMetrics,\n  HalsteadMetrics,\n  LanguageDefinition,\n  LanguageName,\n  MeasureOptions,\n  ModuleMetrics,\n  SyntaxFeatureMetrics,\n  TypeComplexityMetrics,\n} from './types.js';\n\nconst booleanOperators = new Set(['&&', '||', 'and', 'or']);\nconst operatorTexts = new Set([\n  '+',\n  '-',\n  '*',\n  '/',\n  '%',\n  '**',\n  '=',\n  '+=',\n  '-=',\n  '*=',\n  '/=',\n  '%=',\n  '==',\n  '!=',\n  '===',\n  '!==',\n  '<',\n  '<=',\n  '>',\n  '>=',\n  '!',\n  '~',\n  '&',\n  '|',\n  '^',\n  '++',\n  '--',\n  '<<',\n  '>>',\n  '>>>',\n  '=>',\n  '**=',\n  '<<=',\n  '>>=',\n  '>>>=',\n  '&=',\n  '|=',\n  '^=',\n  '&&=',\n  '||=',\n  '??=',\n  '??',\n  '?.',\n  '?',\n  '//',\n  '//=',\n  '@',\n  '@=',\n  ':=',\n  '<-',\n  '<=>',\n  '=~',\n  '..',\n  '...',\n  '..=',\n  '&&',\n  '||',\n  '!~',\n  '&^',\n  '&^=',\n  '&.',\n  // Member access/qualification are classical Halstead operators (floats and range/spread tokens\n  // are distinct leaves, so `.` cannot collide with them). `->` also captures Python/Rust\n  // return-type arrows, consistent with the counted `=>`.\n  '.',\n  '->',\n  '::',\n  '->*',\n  '.*',\n  'sizeof',\n  'alignof',\n  'defined?',\n  'as',\n  // C++ alternative operator tokens parse as anonymous leaves like their symbolic forms.\n  'bitand',\n  'bitor',\n  'xor',\n  'compl',\n  'and_eq',\n  'or_eq',\n  'xor_eq',\n  'not_eq',\n  'and',\n  'or',\n  'not',\n  'in',\n  'is',\n  'instanceof',\n  'typeof',\n  'new',\n  'delete',\n  'return',\n  'throw',\n  'raise',\n  'yield',\n  'await',\n  'co_await',\n  'co_yield',\n  'co_return',\n  'break',\n  'continue',\n]);\n\nconst operandNodeTypes = new Set([\n  'identifier',\n  'property_identifier',\n  'field_identifier',\n  'type_identifier',\n  'constant',\n  'instance_variable',\n  'class_variable',\n  'global_variable',\n  'simple_symbol',\n  'self',\n  'this',\n  'super',\n  // C/C++/Rust built-in types are leaves of their own node type, unlike Go's `type_identifier`.\n  'primitive_type',\n  'boolean_type',\n  'void_type',\n  'auto',\n  'number',\n  'integer',\n  'float',\n  'integer_literal',\n  'float_literal',\n  'int_literal',\n  'rune_literal',\n  'imaginary_literal',\n  'number_literal',\n  'decimal_integer_literal',\n  'hex_integer_literal',\n  'octal_integer_literal',\n  'binary_integer_literal',\n  'decimal_floating_point_literal',\n  'hex_floating_point_literal',\n  'string',\n  'string_literal',\n  // Go raw strings are leaves with no content child, unlike Rust/C++ `raw_string_literal`s.\n  'raw_string_literal',\n  'string_fragment',\n  'multiline_string_fragment',\n  'string_content',\n  'raw_string_content',\n  'template_string',\n  'character_literal',\n  'char_literal',\n  'character',\n  'true',\n  'false',\n  'null',\n  'null_literal',\n  'undefined',\n  'nil',\n  'none',\n]);\n\n/**\n * Non-leaf literals counted as one Halstead operand without descending: Go interpreted strings\n * have no content leaf at all, and regex literals would otherwise count their `/` delimiters as\n * division operators. Interpolated regex contents are deliberately swallowed by the atom.\n */\n// C++ user-defined literals (`42_km`) are atomic too, keeping their suffix in the operand identity,\n// and multi-token built-in types (Java `int`, C `unsigned long`) wrap anonymous keyword leaves so\n// they count as one operand.\nconst atomicOperandNodeTypes = new Set([\n  'interpreted_string_literal',\n  'regex',\n  'user_defined_literal',\n  'integral_type',\n  'floating_point_type',\n  'sized_type_specifier',\n  'placeholder_type_specifier',\n]);\n\ninterface ComplexityResult {\n  cyclomaticComplexity: number;\n  cognitiveComplexity: number;\n  nestingDepth: number;\n}\n\ninterface CommentSpan {\n  line: number;\n  startColumn: number;\n  endColumn: number;\n}\n\ninterface FunctionAnalysis {\n  index: number;\n  name?: string;\n  startLine: number;\n  startColumn: number;\n  endLine: number;\n  returnsJsx: boolean;\n  cyclomaticComplexity: number;\n  cognitiveComplexity: number;\n  nestingDepth: number;\n  callCount: number;\n  parameterCount: number;\n  callees: Set<string>;\n  identifiers: Set<string>;\n}\n\ninterface StructuralMetrics {\n  callGraph: CallGraphMetrics;\n  cohesion: CohesionMetrics;\n  coupling: CouplingMetrics;\n  functions: FunctionMetrics[];\n  module: ModuleMetrics;\n  syntaxFeatures: SyntaxFeatureMetrics;\n  typeComplexity: TypeComplexityMetrics;\n}\n\nexport class TreeMeasurer {\n  private readonly registry = createLanguageRegistry();\n\n  registerLanguage(language: LanguageDefinition): void {\n    this.registry.set(language.name, language);\n    for (const alias of language.aliases ?? []) {\n      this.registry.set(alias, language);\n    }\n  }\n\n  getSupportedLanguages(): LanguageName[] {\n    return [...new Set([...this.registry.values()].map((language) => language.name))];\n  }\n\n  measure(code: string, options: MeasureOptions): CodeMetrics {\n    const language = this.registry.get(options.language);\n    if (!language) {\n      throw new Error(`Unsupported language: ${options.language}`);\n    }\n\n    const parser = new Parser();\n    parser.setLanguage(language.parserLanguage);\n    const tree = parser.parse(code, undefined, {\n      bufferSize: code.length + 1,\n    });\n    const root = tree.rootNode;\n    const functions = collectNodes(root, new Set(language.functionNodeTypes)).filter(\n      (node) => !isLambdaBodyBlock(node) && isImplementedFunction(node)\n    );\n    const structuralMetrics = measureStructuralMetrics(root, functions, language);\n    const functionMetrics = structuralMetrics.functions;\n    const globalComplexity = measureComplexity(root, language, 0, false);\n    const { lines, codeLineNumbers } = classifyLines(code, root);\n    const halstead = measureHalstead(root, code);\n\n    return {\n      language: language.name,\n      bytes: Buffer.byteLength(code),\n      lines,\n      functions: functionMetrics,\n      classCount: countClasses(root, language),\n      functionCount: functionMetrics.length,\n      cyclomaticComplexity: globalComplexity.cyclomaticComplexity,\n      maxCyclomaticComplexity: maxMetric(functionMetrics, 'cyclomaticComplexity'),\n      cognitiveComplexity: globalComplexity.cognitiveComplexity,\n      maxCognitiveComplexity: maxMetric(functionMetrics, 'cognitiveComplexity'),\n      nestingDepth: globalComplexity.nestingDepth,\n      callGraph: structuralMetrics.callGraph,\n      coupling: structuralMetrics.coupling,\n      module: structuralMetrics.module,\n      cohesion: structuralMetrics.cohesion,\n      syntaxFeatures: structuralMetrics.syntaxFeatures,\n      typeComplexity: structuralMetrics.typeComplexity,\n      duplication: measureDuplication(root, codeLineNumbers),\n      halstead,\n      maintainabilityIndex: calculateMaintainabilityIndex(\n        halstead.volume,\n        globalComplexity.cyclomaticComplexity,\n        lines.code\n      ),\n      syntaxTree: options.includeSyntaxTree ? root.toString() : undefined,\n    };\n  }\n}\n\nexport const defaultMeasurer = new TreeMeasurer();\n\nexport function measureCode(code: string, options: MeasureOptions): CodeMetrics {\n  return defaultMeasurer.measure(code, options);\n}\n\nfunction measureStructuralMetrics(\n  root: Parser.SyntaxNode,\n  functions: Parser.SyntaxNode[],\n  language: LanguageDefinition\n): StructuralMetrics {\n  const constructedTypeNames = collectConstructedTypeNames(root, language);\n  const analyses = functions.map((node, index) => analyzeFunction(node, language, index, constructedTypeNames));\n  const callGraph = measureCallGraph(analyses);\n  const functionsWithGraph = analyses.map((analysis) => ({\n    name: analysis.name,\n    startLine: analysis.startLine,\n    startColumn: analysis.startColumn,\n    endLine: analysis.endLine,\n    returnsJsx: analysis.returnsJsx,\n    cyclomaticComplexity: analysis.cyclomaticComplexity,\n    cognitiveComplexity: analysis.cognitiveComplexity,\n    nestingDepth: analysis.nestingDepth,\n    callCount: analysis.callCount,\n    uniqueCalleeCount: analysis.callees.size,\n    fanIn: callGraph.fanInByIndex.get(analysis.index) ?? 0,\n    fanOut: callGraph.fanOutByIndex.get(analysis.index) ?? 0,\n    parameterCount: analysis.parameterCount,\n    recursive: callGraph.recursiveIndexes.has(analysis.index),\n  }));\n\n  return {\n    functions: functionsWithGraph,\n    callGraph: callGraph.metrics,\n    coupling: measureCoupling(root, language),\n    module: measureModule(root, language),\n    cohesion: measureCohesion(analyses),\n    syntaxFeatures: measureSyntaxFeatures(root, language.name),\n    typeComplexity: measureTypeComplexity(root),\n  };\n}\n\nfunction analyzeFunction(\n  node: Parser.SyntaxNode,\n  language: LanguageDefinition,\n  index: number,\n  constructedTypeNames: Set<string>\n): FunctionAnalysis {\n  const complexity = measureComplexity(node, language, 0, true);\n  const calls = collectCalls(node, language, constructedTypeNames);\n  return {\n    index,\n    name: findFunctionName(node),\n    startLine: node.startPosition.row + 1,\n    startColumn: node.startPosition.column,\n    endLine: node.endPosition.row + 1,\n    returnsJsx: returnsJsx(node, language),\n    cyclomaticComplexity: complexity.cyclomaticComplexity,\n    cognitiveComplexity: complexity.cognitiveComplexity,\n    nestingDepth: complexity.nestingDepth,\n    callCount: calls.callCount,\n    parameterCount: countParameters(node),\n    callees: calls.callees,\n    identifiers: collectIdentifiers(node),\n  };\n}\n\n/** Counts declared parameters of a function/method, ignoring punctuation and comments. */\nfunction countParameters(node: Parser.SyntaxNode): number {\n  // An unparenthesized arrow-function parameter (`x => x + 1`) is a bare `parameter` field.\n  if (node.childForFieldName('parameter')) {\n    return 1;\n  }\n\n  const parametersNode = findParametersNode(node);\n  if (!parametersNode) {\n    return 0;\n  }\n\n  // A Java bare lambda parameter (`x -> x + 1`) puts a lone identifier in the `parameters` field.\n  if (parametersNode.type === 'identifier') {\n    return 1;\n  }\n\n  // Ruby block-locals after `;` (`{ |x; memo| ... }`) occupy `locals` fields and receive no arguments.\n  const blockLocalIds = new Set(findChildrenByFieldName(parametersNode, 'locals').map((child) => child.id));\n  // Rust's `self` and Java's explicit receiver (`void f(X this)`) are not declared parameters, and\n  // C/C++ `f(void)` declares none.\n  const namedCount = sum(\n    parametersNode.namedChildren\n      .filter(\n        (child) =>\n          child.type !== 'comment' &&\n          child.type !== 'self_parameter' &&\n          child.type !== 'receiver_parameter' &&\n          // Python's PEP 570/3102 markers (`/`, `*`) separate parameter kinds but bind nothing.\n          child.type !== 'positional_separator' &&\n          child.type !== 'keyword_separator' &&\n          !blockLocalIds.has(child.id) &&\n          !isVoidParameter(child)\n      )\n      // Go declares several names per declaration (`a, b int`); each name is a parameter.\n      .map((child) =>\n        child.type === 'parameter_declaration' ? Math.max(1, findChildrenByFieldName(child, 'name').length) : 1\n      )\n  );\n  // C++ C-style varargs (`int f(int a, ...)`) leave `...` as an anonymous token, unlike C's named\n  // `variadic_parameter`.\n  const anonymousVariadicCount = parametersNode.children.filter(\n    (child) => !child.isNamed && child.text === '...'\n  ).length;\n  return namedCount + anonymousVariadicCount;\n}\n\n/** C/C++ `int f(void)` has a `parameter_declaration` whose type is a bare `void` with no declarator. */\nfunction isVoidParameter(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'parameter_declaration' &&\n    node.childForFieldName('declarator') === null &&\n    node.childForFieldName('type')?.text === 'void'\n  );\n}\n\nfunction findParametersNode(node: Parser.SyntaxNode): Parser.SyntaxNode | undefined {\n  const direct = node.childForFieldName('parameters');\n  if (direct) {\n    return direct;\n  }\n\n  // A Java compact constructor implicitly takes the record's components, declared on the\n  // `record_declaration` two levels up (via `class_body`).\n  if (node.type === 'compact_constructor_declaration') {\n    return node.parent?.parent?.childForFieldName('parameters') ?? undefined;\n  }\n\n  // C/C++ parameters hang off the (possibly pointer/reference-wrapped) declarator, not the\n  // definition itself.\n  let declarator: Parser.SyntaxNode | null | undefined = node.childForFieldName('declarator');\n  while (declarator) {\n    const parameters = declarator.childForFieldName('parameters');\n    if (parameters) {\n      return parameters;\n    }\n    declarator = nextDeclarator(declarator);\n  }\n\n  return node.namedChildren.find((child) => child.type === 'formal_parameters' || child.type === 'parameter_list');\n}\n\nfunction measureCallGraph(analyses: FunctionAnalysis[]): {\n  fanInByIndex: Map<number, number>;\n  fanOutByIndex: Map<number, number>;\n  metrics: CallGraphMetrics;\n  recursiveIndexes: Set<number>;\n} {\n  const indexesByName = mapUniqueFunctionIndexesByName(analyses);\n  const functionNames = new Set(indexesByName.keys());\n  const fanInByIndex = new Map<number, number>();\n  const fanOutByIndex = new Map<number, number>();\n  const graph = new Map<number, Set<number>>();\n  let callCount = 0;\n  let internalCallCount = 0;\n  const allCallees = new Set<string>();\n\n  for (const analysis of analyses) {\n    callCount += analysis.callCount;\n    for (const callee of analysis.callees) {\n      allCallees.add(callee);\n    }\n\n    const internalCalleeNames = new Set([...analysis.callees].filter((callee) => functionNames.has(callee)));\n    const internalCalleeIndexes = new Set<number>();\n    for (const callee of internalCalleeNames) {\n      const calleeIndex = indexesByName.get(callee);\n      if (calleeIndex !== undefined) {\n        internalCalleeIndexes.add(calleeIndex);\n      }\n    }\n\n    graph.set(analysis.index, internalCalleeIndexes);\n    fanOutByIndex.set(analysis.index, internalCalleeNames.size);\n    internalCallCount += internalCalleeNames.size;\n    for (const calleeIndex of internalCalleeIndexes) {\n      fanInByIndex.set(calleeIndex, (fanInByIndex.get(calleeIndex) ?? 0) + 1);\n    }\n  }\n\n  const recursiveIndexes = findRecursiveIndexes(graph);\n\n  return {\n    fanInByIndex,\n    fanOutByIndex,\n    recursiveIndexes,\n    metrics: {\n      callCount,\n      uniqueCalleeCount: allCallees.size,\n      internalCallCount,\n      internalEdgeCount: sum([...graph.values()].map((callees) => callees.size)),\n      recursiveFunctionCount: recursiveIndexes.size,\n      maxFanIn: maxMapValue(fanInByIndex),\n      maxFanOut: maxMapValue(fanOutByIndex),\n      maxCallDepth: measureMaxCallDepth(graph),\n    },\n  };\n}\n\nfunction mapUniqueFunctionIndexesByName(analyses: FunctionAnalysis[]): Map<string, number> {\n  const indexesByName = new Map<string, number | undefined>();\n  for (const analysis of analyses) {\n    if (!analysis.name) {\n      continue;\n    }\n\n    indexesByName.set(analysis.name, indexesByName.has(analysis.name) ? undefined : analysis.index);\n  }\n  return new Map([...indexesByName.entries()].filter((entry): entry is [string, number] => entry[1] !== undefined));\n}\n\n/**\n * C++ `function_definition` also covers pure-virtual/`= default`/`= delete` members and Java\n * `method_declaration` covers abstract/interface methods; those have no `body` and are signatures,\n * not implementations, matching how TypeScript method signatures are excluded.\n */\nconst bodyRequiredFunctionTypes = new Set([\n  'function_definition',\n  'method_declaration',\n  'constructor_declaration',\n  'compact_constructor_declaration',\n  // Rust trait method signatures (`fn required(&self);`) never carry a body.\n  'function_signature_item',\n]);\n\nfunction isImplementedFunction(node: Parser.SyntaxNode): boolean {\n  if (!bodyRequiredFunctionTypes.has(node.type) || node.childForFieldName('body') !== null) {\n    return true;\n  }\n\n  // C++ constructor/destructor function-try-blocks carry their `try_statement` outside the\n  // `body` field; they are implementations, unlike `= 0`/`= default`/`= delete` members.\n  return node.namedChildren.some((child) => child.type === 'try_statement');\n}\n\n/**\n * A Ruby stabby lambda (`->(x) { ... }`) wraps its body in a `block`/`do_block`, which is itself a\n * function node type; the wrapper is part of the lambda, not a separate function, so it must not\n * count as one or act as a nested-function boundary.\n */\nfunction isLambdaBodyBlock(node: Parser.SyntaxNode): boolean {\n  return (node.type === 'block' || node.type === 'do_block') && node.parent?.type === 'lambda';\n}\n\nfunction isFunctionBoundary(node: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  return functionNodeTypes.has(node.type) && !isLambdaBodyBlock(node);\n}\n\nfunction measureComplexity(\n  node: Parser.SyntaxNode,\n  language: LanguageDefinition,\n  nesting: number,\n  stopAtNestedFunctions: boolean\n): ComplexityResult {\n  let cyclomaticComplexity = 1;\n  let cognitiveComplexity = 0;\n  let nestingDepth = nesting;\n  const functionNodes = new Set(language.functionNodeTypes);\n  const decisionNodes = new Set(language.decisionNodeTypes);\n  const nestingNodes = new Set(language.nestingNodeTypes);\n\n  function visit(current: Parser.SyntaxNode, currentNesting: number, insideRoot: boolean): void {\n    if (stopAtNestedFunctions && !insideRoot && isFunctionBoundary(current, functionNodes)) {\n      return;\n    }\n\n    // Anonymous keyword tokens can share a type with named nodes (Ruby's `if` node contains an\n    // `if` keyword token), so only named nodes count as decisions.\n    const isDecision = current.isNamed && decisionNodes.has(current.type) && !isDefaultSwitchBranch(current);\n    const isNesting = current.isNamed && nestingNodes.has(current.type) && !isDefaultSwitchBranch(current);\n    // `elsif`/`elif`/`else if` continue a flat chain: they add a decision without a nesting\n    // surcharge, and their bodies stay at the chain's nesting level (Sonar cognitive-complexity\n    // semantics); genuinely nested conditionals inside those bodies still deepen.\n    const isContinuation = isDecision && isFlatChainContinuation(current);\n\n    if (isDecision) {\n      cyclomaticComplexity += 1;\n      cognitiveComplexity += isContinuation ? 1 : 1 + currentNesting;\n    }\n\n    if (isBooleanOperator(current)) {\n      cyclomaticComplexity += 1;\n      cognitiveComplexity += 1;\n    }\n\n    // Pattern guards (Java `when`, Ruby `in y if ...`, Python `case n if ...`, Rust `n if ... =>`)\n    // add one independent execution path without nesting.\n    if (isPatternGuard(current)) {\n      cyclomaticComplexity += 1;\n      cognitiveComplexity += 1;\n    }\n\n    const childNesting = isNesting && !isContinuation ? currentNesting + 1 : currentNesting;\n    nestingDepth = Math.max(nestingDepth, childNesting);\n\n    for (const child of current.children) {\n      visit(child, childNesting, false);\n    }\n  }\n\n  for (const child of node.children) {\n    visit(child, nesting, false);\n  }\n\n  return { cyclomaticComplexity, cognitiveComplexity, nestingDepth };\n}\n\n/** Java `guard`, Ruby `if_guard`, Python `if_clause`, and Rust guards inside `match_pattern`. */\nfunction isPatternGuard(node: Parser.SyntaxNode): boolean {\n  if (!node.isNamed) {\n    return false;\n  }\n  if (node.type === 'guard' || node.type === 'if_guard' || node.type === 'unless_guard' || node.type === 'if_clause') {\n    return true;\n  }\n  return node.type === 'match_pattern' && node.children.some((child) => !child.isNamed && child.type === 'if');\n}\n\n/** Ruby `elsif`, Python `elif`, and `else if` (an if node in an else/alternative position). */\nfunction isFlatChainContinuation(node: Parser.SyntaxNode): boolean {\n  if (node.type === 'elsif' || node.type === 'elif_clause') {\n    return true;\n  }\n  if (node.type !== 'if_statement' && node.type !== 'if_expression' && node.type !== 'if') {\n    return false;\n  }\n  const parent = node.parent;\n  if (!parent) {\n    return false;\n  }\n  // JS/C/C++/Rust wrap `else if` in an else clause; Java/Go put it directly in `alternative`.\n  return parent.type === 'else_clause' || parent.childForFieldName('alternative')?.id === node.id;\n}\n\n/**\n * C/C++ `default:` shares the `case_statement` node type with `case` (only `case` has a `value`\n * field), and Java's default group/rule carries an expressionless `switch_label`; a default branch\n * adds no decision, so these must not count toward complexity or nesting.\n */\nfunction isDefaultSwitchBranch(node: Parser.SyntaxNode): boolean {\n  if (node.type === 'case_statement') {\n    return node.childForFieldName('value') === null;\n  }\n\n  if (node.type === 'switch_block_statement_group' || node.type === 'switch_rule') {\n    const label = node.namedChildren.find((child) => child.type === 'switch_label');\n    return label !== undefined && label.namedChildCount === 0;\n  }\n\n  // Python `case _:` / `case y:` and Rust `_ =>` fallback arms are unconditional like `default`\n  // (a bare Python name is always a capture); a guard is charged separately as a flat decision,\n  // so the arm itself still adds nothing. Rust bare identifiers are NOT suppressed: they can name\n  // constants or unit variants, which the grammar cannot distinguish from captures.\n  if (node.type === 'case_clause' || node.type === 'match_arm') {\n    const pattern = node.namedChildren.find((child) => child.type === 'case_pattern' || child.type === 'match_pattern');\n    if (!pattern) {\n      return false;\n    }\n    if (pattern.child(0)?.type === '_' && (pattern.childCount === 1 || pattern.child(1)?.type === 'if')) {\n      return true;\n    }\n    const soleChild = pattern.namedChildCount === 1 ? pattern.namedChild(0) : undefined;\n    return (\n      node.type === 'case_clause' &&\n      soleChild?.type === 'dotted_name' &&\n      soleChild.namedChildCount === 1 &&\n      soleChild.namedChild(0)?.type === 'identifier'\n    );\n  }\n\n  // Ruby `in y` binds unconditionally (bare lowercase names are variable captures; constants and\n  // literals are tests).\n  if (node.type === 'in_clause') {\n    return node.namedChild(0)?.type === 'identifier';\n  }\n\n  return false;\n}\n\n/** Parents under which `&&`/`||`/`and`/`or` tokens are actual boolean operators. */\nconst booleanOperatorParentTypes = new Set(['binary_expression', 'binary', 'boolean_operator']);\n\n/**\n * The parent guard is required because the same tokens appear in non-boolean syntax: C++ rvalue\n * references (`int&&`), ref-qualifiers, `operator&&`, and Rust's empty closure parameter list\n * (`|| 5`) must not count as decisions.\n */\nfunction isBooleanOperator(node: Parser.SyntaxNode): boolean {\n  if (node.isNamed || !booleanOperators.has(node.text)) {\n    return false;\n  }\n\n  const parent = node.parent;\n  return parent !== null && booleanOperatorParentTypes.has(parent.type);\n}\n\nfunction collectCalls(\n  root: Parser.SyntaxNode,\n  language: LanguageDefinition,\n  constructedTypeNames: Set<string> = new Set()\n): { callCount: number; callees: Set<string> } {\n  const callees = new Set<string>();\n  const functionNodeTypes = new Set(language.functionNodeTypes);\n  let callCount = 0;\n\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): void {\n    if (!insideRoot && isFunctionBoundary(node, functionNodeTypes)) {\n      return;\n    }\n\n    // C++ casts (`int(x)`, `static_cast<int>(x)`) parse as call expressions but invoke nothing.\n    if (language.name === 'cpp' && isCppCastExpression(node)) {\n      // Not a call: fall through to children only.\n    } else if (isCallNode(node)) {\n      callCount += 1;\n      // C++ `new Widget()` and functional construction `Widget(1)` / `ns::Widget(1)` /\n      // `Box<int>(1)` name an overloaded constructor, so — like direct construction — they count\n      // as calls without a callee edge. JS `new Foo()` keeps its edge to the function.\n      const isCppConstructorCall =\n        language.name === 'cpp' &&\n        (node.type === 'new_expression' ||\n          (node.type === 'call_expression' &&\n            constructedTypeNames.has(cppBaseTypeName(node.childForFieldName('function')) ?? '')));\n      const callee = isCppConstructorCall ? undefined : findCalleeName(node);\n      if (callee) {\n        callees.add(callee);\n      }\n      // Ruby abbreviated assignment on a receiver (`self.foo += 1`, `self.foo ||= x`) invokes the\n      // getter (the call node itself) AND the setter, so the setter is one extra call.\n      if (\n        language.name === 'ruby' &&\n        node.type === 'call' &&\n        node.parent?.type === 'operator_assignment' &&\n        node.parent.childForFieldName('left')?.id === node.id\n      ) {\n        callCount += 1;\n        const setterMethod = node.childForFieldName('method');\n        if (setterMethod) {\n          callees.add(`${setterMethod.text}=`);\n        }\n      }\n    } else if (isRubyImplicitCall(node, language) || isCppConstruction(node, constructedTypeNames)) {\n      // `yield x` invokes the block, not its argument `x`, and constructors are overloaded by\n      // definition, so neither adds a callee edge.\n      callCount += 1;\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child, false);\n    }\n  }\n\n  visit(root, true);\n  return { callCount, callees };\n}\n\nconst cppNamedCasts = new Set(['static_cast', 'dynamic_cast', 'const_cast', 'reinterpret_cast']);\n\n/** C++ casts parse as call expressions (`int(x)`, `static_cast<int>(x)`) but invoke nothing. */\nfunction isCppCastExpression(node: Parser.SyntaxNode): boolean {\n  if (node.type !== 'call_expression') {\n    return false;\n  }\n  const callee = node.childForFieldName('function');\n  if (callee?.type === 'primitive_type') {\n    return true;\n  }\n  const name = callee?.type === 'template_function' ? callee.childForFieldName('name')?.text : callee?.text;\n  return name !== undefined && cppNamedCasts.has(name);\n}\n\n/**\n * C++ direct and list construction (`Foo a(1)`, `Foo b{2}`, `Foo{3}`) invoke a constructor without\n * a call node. Only types defined in the measured tree count, so scalar initialization\n * (`int a(1)`) and external types stay excluded.\n */\nfunction isCppConstruction(node: Parser.SyntaxNode, constructedTypeNames: Set<string>): boolean {\n  if (constructedTypeNames.size === 0) {\n    return false;\n  }\n  if (node.type === 'compound_literal_expression') {\n    return constructedTypeNames.has(cppBaseTypeName(node.childForFieldName('type')) ?? '');\n  }\n  if (node.type === 'init_declarator') {\n    const value = node.childForFieldName('value');\n    if (value?.type !== 'argument_list' && value?.type !== 'initializer_list') {\n      return false;\n    }\n    return constructedTypeNames.has(cppBaseTypeName(node.parent?.childForFieldName('type')) ?? '');\n  }\n  // Default construction (`Widget value;`, `Widget values[2];`): a bare identifier or array\n  // declarator of a local class type. `extern` declarations declare without constructing, and\n  // pointer chains construct nothing.\n  if (\n    (node.type === 'identifier' || node.type === 'array_declarator') &&\n    node.parent?.type === 'declaration' &&\n    findChildrenByFieldName(node.parent, 'declarator').some((declarator) => declarator.id === node.id) &&\n    !hasStorageClass(node.parent, 'extern')\n  ) {\n    let current: Parser.SyntaxNode | null | undefined = node;\n    while (current?.type === 'array_declarator') {\n      current = current.childForFieldName('declarator');\n    }\n    return (\n      current?.type === 'identifier' &&\n      constructedTypeNames.has(cppBaseTypeName(node.parent.childForFieldName('type')) ?? '')\n    );\n  }\n  // Base/delegating constructor initializers (`Widget() : Base(1) {}`). The grammar names both\n  // base classes and members as `field_identifier`, so they are told apart by whether the name is\n  // a locally defined class — the same base-name trade documented on cppBaseTypeName.\n  if (node.type === 'field_initializer') {\n    const nameNode = node.namedChild(0);\n    const name = nameNode?.type === 'field_identifier' ? nameNode.text : cppBaseTypeName(nameNode);\n    return constructedTypeNames.has(name ?? '');\n  }\n  return false;\n}\n\n/**\n * Base name of a possibly qualified/templated C++ type or callee (`ns::Box<int>` -> `Box`).\n * Matching by base name treats a same-named external type as local — a conservative trade\n * accepted over tracking full namespace scopes.\n */\nfunction cppBaseTypeName(node: Parser.SyntaxNode | null | undefined): string | undefined {\n  let current: Parser.SyntaxNode | null | undefined = node;\n  while (current) {\n    if (current.type === 'type_identifier' || current.type === 'identifier') {\n      return current.text;\n    }\n    if (\n      current.type === 'qualified_identifier' ||\n      current.type === 'scoped_identifier' ||\n      current.type === 'template_type' ||\n      current.type === 'template_function'\n    ) {\n      current = current.childForFieldName('name');\n      continue;\n    }\n    return undefined;\n  }\n  return undefined;\n}\n\nconst cppClassSpecifierTypes = new Set(['class_specifier', 'struct_specifier', 'union_specifier']);\n\n/** Names of C++ class-like types defined (with a body) in this tree, for construction counting. */\nfunction collectConstructedTypeNames(root: Parser.SyntaxNode, language: LanguageDefinition): Set<string> {\n  const names = new Set<string>();\n  if (language.name !== 'cpp') {\n    return names;\n  }\n  for (const node of collectNodes(root, cppClassSpecifierTypes)) {\n    const name = node.childForFieldName('name')?.text;\n    if (name && node.childForFieldName('body')) {\n      names.add(name);\n    }\n  }\n  return names;\n}\n\n/**\n * Ruby's bare `yield` and `super` invoke without a `call` node (only `super()` parses as `call`,\n * whose `super` child must not double-count), so they add to the call count without a callee edge.\n * Language-gated because Python `yield` and JS/Java `super` children are not extra calls.\n * Bare receiverless zero-argument sends (`helper` alone) are deliberately NOT counted: they parse\n * as plain identifiers, and telling them apart from local-variable reads requires Ruby's\n * lexically-ordered binding analysis — a static-analysis boundary this measurer does not cross.\n */\nfunction isRubyImplicitCall(node: Parser.SyntaxNode, language: LanguageDefinition): boolean {\n  if (language.name !== 'ruby') {\n    return false;\n  }\n  return node.type === 'yield' || (node.type === 'super' && node.parent?.type !== 'call');\n}\n\nfunction collectIdentifiers(root: Parser.SyntaxNode): Set<string> {\n  const identifiers = new Set<string>();\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (\n      node.type === 'identifier' ||\n      node.type === 'property_identifier' ||\n      node.type === 'field_identifier' ||\n      node.type === 'constant' ||\n      node.type === 'instance_variable' ||\n      node.type === 'class_variable' ||\n      node.type === 'global_variable'\n    ) {\n      identifiers.add(node.text);\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return identifiers;\n}\n\n/** C/C++ `struct Foo`-style type references reuse the declaration node type, so a body is required. */\nfunction countClasses(root: Parser.SyntaxNode, language: LanguageDefinition): number {\n  return collectNodes(root, new Set(language.classNodeTypes)).filter(isCountableClassNode).length;\n}\n\n/**\n * C/C++ `struct Foo;` forward declarations define no class, and Java `new Runnable() { ... }` /\n * enum constants define an anonymous class only when they carry a `class_body` (JLS 15.9.5).\n */\nfunction isCountableClassNode(node: Parser.SyntaxNode): boolean {\n  if (node.type === 'object_creation_expression' || node.type === 'enum_constant') {\n    return node.namedChildren.some((child) => child.type === 'class_body');\n  }\n  return !node.type.endsWith('_specifier') || node.childForFieldName('body') !== null;\n}\n\nfunction collectNodes(root: Parser.SyntaxNode, nodeTypes: Set<string>): Parser.SyntaxNode[] {\n  const nodes: Parser.SyntaxNode[] = [];\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (nodeTypes.has(node.type)) {\n      nodes.push(node);\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return nodes;\n}\n\nfunction returnsJsx(root: Parser.SyntaxNode, language: LanguageDefinition): boolean {\n  const functionNodeTypes = new Set(language.functionNodeTypes);\n\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): boolean {\n    if (!insideRoot && functionNodeTypes.has(node.type)) {\n      return false;\n    }\n\n    if (node.type === 'return_statement') {\n      return containsJsxExpression(node, functionNodeTypes) || containsReactCreateElementCall(node, functionNodeTypes);\n    }\n\n    if (\n      root.type === 'arrow_function' &&\n      node === getArrowFunctionBody(root) &&\n      node.type !== 'statement_block' &&\n      !functionNodeTypes.has(node.type)\n    ) {\n      return containsJsxExpression(node, functionNodeTypes) || containsReactCreateElementCall(node, functionNodeTypes);\n    }\n\n    for (const child of node.namedChildren) {\n      if (visit(child, false)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  return visit(root, true);\n}\n\nfunction getArrowFunctionBody(node: Parser.SyntaxNode): Parser.SyntaxNode | undefined {\n  return node.childForFieldName('body') ?? node.namedChild(node.namedChildCount - 1) ?? undefined;\n}\n\nfunction containsJsxExpression(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  return containsNode(\n    root,\n    functionNodeTypes,\n    (node) => node.type.startsWith('jsx_') || isJsxMappingCall(node, functionNodeTypes)\n  );\n}\n\nfunction containsReactCreateElementCall(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  return containsNode(root, functionNodeTypes, isReactCreateElementCall);\n}\n\nfunction containsNode(\n  root: Parser.SyntaxNode,\n  functionNodeTypes: Set<string>,\n  predicate: (node: Parser.SyntaxNode) => boolean\n): boolean {\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): boolean {\n    if (!insideRoot && functionNodeTypes.has(node.type)) {\n      return false;\n    }\n\n    if (predicate(node)) {\n      return true;\n    }\n\n    for (const child of node.namedChildren) {\n      if (visit(child, false)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  return visit(root, true);\n}\n\nfunction isJsxMappingCall(node: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  if (!isCallNode(node) || !isArrayMappingCallee(node.childForFieldName('function') ?? node.namedChild(0))) {\n    return false;\n  }\n\n  return node.namedChildren.some((child) => containsReturnedJsxFunction(child, functionNodeTypes));\n}\n\nfunction isArrayMappingCallee(node: Parser.SyntaxNode | null): boolean {\n  if (!node) {\n    return false;\n  }\n\n  const calleeName = findRightmostIdentifier(node);\n  return calleeName === 'map' || calleeName === 'flatMap';\n}\n\nfunction containsReturnedJsxFunction(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  if (functionNodeTypes.has(root.type)) {\n    return returnsJsxFromFunctionNode(root, functionNodeTypes);\n  }\n\n  return root.namedChildren.some((child) => containsReturnedJsxFunction(child, functionNodeTypes));\n}\n\nfunction returnsJsxFromFunctionNode(root: Parser.SyntaxNode, functionNodeTypes: Set<string>): boolean {\n  const body = root.type === 'arrow_function' ? getArrowFunctionBody(root) : undefined;\n  if (body && body.type !== 'statement_block' && !functionNodeTypes.has(body.type)) {\n    return containsJsxExpression(body, functionNodeTypes) || containsReactCreateElementCall(body, functionNodeTypes);\n  }\n\n  return containsOwnReturnNode(\n    root,\n    functionNodeTypes,\n    (node) => containsJsxExpression(node, functionNodeTypes) || containsReactCreateElementCall(node, functionNodeTypes)\n  );\n}\n\nfunction containsOwnReturnNode(\n  root: Parser.SyntaxNode,\n  functionNodeTypes: Set<string>,\n  predicate: (node: Parser.SyntaxNode) => boolean\n): boolean {\n  function visit(node: Parser.SyntaxNode, insideRoot: boolean): boolean {\n    if (!insideRoot && functionNodeTypes.has(node.type)) {\n      return false;\n    }\n\n    if (node.type === 'return_statement' && predicate(node)) {\n      return true;\n    }\n\n    for (const child of node.namedChildren) {\n      if (visit(child, false)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  return visit(root, true);\n}\n\nfunction measureModule(root: Parser.SyntaxNode, language: LanguageDefinition): ModuleMetrics {\n  const importSources = new Set<string>();\n\n  function visitImports(node: Parser.SyntaxNode): void {\n    if (isImportSourceNode(node, language)) {\n      for (const source of findImportSources(node, language, { expandPythonSubmodules: true })) {\n        importSources.add(source);\n      }\n    }\n\n    for (const child of node.namedChildren) {\n      visitImports(child);\n    }\n  }\n\n  visitImports(root);\n\n  return {\n    declarations: collectModuleDeclarations(root, language),\n    importSources: [...importSources],\n  };\n}\n\nfunction collectModuleDeclarations(root: Parser.SyntaxNode, language: LanguageDefinition): DeclarationMetrics[] {\n  const exportedNames = collectExportedNames(root);\n  const scope = language.name === 'java' ? findJavaPackageScope(root) : '';\n  return root.namedChildren\n    .flatMap((child) => collectTopLevelDeclarations(child, false, scope, language.name === 'cpp'))\n    .map((declaration) => (exportedNames.has(declaration.name) ? { ...declaration, exported: true } : declaration));\n}\n\n/** Java top-level declarations are qualified by their package so simple names stay distinct. */\nfunction findJavaPackageScope(root: Parser.SyntaxNode): string {\n  const packageNode = root.namedChildren.find((child) => child.type === 'package_declaration');\n  const nameNode = packageNode?.namedChildren.find(\n    (child) => child.type === 'scoped_identifier' || child.type === 'identifier'\n  );\n  return nameNode ? `${nameNode.text}::` : '';\n}\n\nconst rubyTypeNodeTypes = new Set(['module', 'class', 'singleton_class']);\n\nfunction collectTopLevelDeclarations(\n  node: Parser.SyntaxNode,\n  exported: boolean,\n  scope = '',\n  isCpp = false\n): DeclarationMetrics[] {\n  if (isModuleExportNode(node)) {\n    return node.namedChildren.flatMap((child) => collectTopLevelDeclarations(child, true, scope, isCpp));\n  }\n\n  // C++ namespaces qualify their contents so `Alpha::ServiceThing` and `Beta::ServiceThing` stay\n  // distinct in cross-file symbol groups; anonymous namespaces give internal linkage and declare\n  // no cross-file symbols at all.\n  if (node.type === 'namespace_definition') {\n    const name = node.childForFieldName('name')?.text;\n    if (!name) {\n      return [];\n    }\n    const bodyNode = node.childForFieldName('body');\n    return (bodyNode?.namedChildren ?? []).flatMap((child) =>\n      collectTopLevelDeclarations(child, exported, `${scope}${name}::`, isCpp)\n    );\n  }\n\n  if (isDeclarationContainer(node)) {\n    return node.namedChildren.flatMap((child) => collectTopLevelDeclarations(child, exported, scope, isCpp));\n  }\n\n  // C/C++ global variables live in `declaration` nodes with one or more declarators.\n  if (node.type === 'declaration') {\n    return qualifyDeclarations(declarationsFromCDeclaration(node, exported, isCpp), scope);\n  }\n\n  // C `typedef` declares alias name(s) and possibly a tagged type in one node.\n  if (node.type === 'type_definition') {\n    return qualifyDeclarations(declarationsFromTypeDefinition(node, exported), scope);\n  }\n\n  // Ruby modules/classes nest further types in their body, like C++ namespaces.\n  if (rubyTypeNodeTypes.has(node.type)) {\n    return declarationsFromRubyType(node, exported, scope);\n  }\n\n  // Ruby constant assignment (`FOO = 1`, `MIN, MAX = 1, 10`, `LIMIT ||= 10`) is the language's\n  // only constant syntax; constants are a module's canonical public API. Other grammars never\n  // put a `constant` node on an assignment LHS.\n  if (node.type === 'assignment' || node.type === 'operator_assignment') {\n    return qualifyDeclarations(rubyConstantDeclarations(node, exported), scope, true);\n  }\n\n  return qualifyDeclarations(declarationFromNode(node, exported), scope);\n}\n\n/**\n * Prefixes declarations with the enclosing scope. Ruby callers pass `skipQualified` because\n * `class A::B` / `A::C = 1` names are already qualified and re-prefixing would double them\n * (`A::A::B`); C++ out-of-line names (`Widget::process`) must still gain their namespace prefix.\n */\nfunction qualifyDeclarations(\n  declarations: DeclarationMetrics[],\n  scope: string,\n  skipQualified = false\n): DeclarationMetrics[] {\n  if (!scope) {\n    return declarations;\n  }\n  return declarations.map((declaration) =>\n    skipQualified && declaration.name.includes('::')\n      ? declaration\n      : { ...declaration, name: `${scope}${declaration.name}` }\n  );\n}\n\n/**\n * Emits a Ruby type and its nested types. Methods are intentionally not collected as module\n * declarations: names like `initialize` repeat everywhere and would flood cross-file\n * duplicate-symbol groups.\n */\nfunction declarationsFromRubyType(node: Parser.SyntaxNode, exported: boolean, scope = ''): DeclarationMetrics[] {\n  const declarations = qualifyDeclarations(declarationFromNode(node, exported), scope, true);\n  // Nested types and constants are qualified by their enclosing module path (`Alpha::LIMIT`) so\n  // same-named symbols under different modules stay distinct in cross-file symbol groups.\n  const childScope = declarations[0] ? `${declarations[0].name}::` : scope;\n  const bodyNode = node.childForFieldName('body');\n  for (const child of bodyNode?.namedChildren ?? []) {\n    if (rubyTypeNodeTypes.has(child.type)) {\n      declarations.push(...declarationsFromRubyType(child, exported, childScope));\n    } else if (child.type === 'assignment' || child.type === 'operator_assignment') {\n      declarations.push(...qualifyDeclarations(rubyConstantDeclarations(child, exported), childScope, true));\n    }\n  }\n  return declarations;\n}\n\n/**\n * Emits declarations for Ruby constant assignments: `CONST = ...`, qualified `A::CONST = ...`,\n * multiple `MIN, MAX = ...`, and `CONST ||= ...` (the only operator assignment that can define an\n * unset constant); other assignments (locals, ivars, `Foo.bar =` setters) declare nothing.\n */\nfunction rubyConstantDeclarations(node: Parser.SyntaxNode, exported: boolean): DeclarationMetrics[] {\n  if (node.type === 'operator_assignment' && !node.children.some((child) => !child.isNamed && child.text === '||=')) {\n    return [];\n  }\n  const left = node.childForFieldName('left');\n  if (!left) {\n    return [];\n  }\n  const targets = left.type === 'left_assignment_list' ? left.namedChildren : [left];\n  return targets\n    .filter(\n      (target) =>\n        target.type === 'constant' ||\n        (target.type === 'scope_resolution' && target.childForFieldName('name')?.type === 'constant')\n    )\n    .map((target) => ({ exported, name: target.text, startLine: target.startPosition.row + 1 }));\n}\n\nfunction declarationsFromTypeDefinition(node: Parser.SyntaxNode, exported: boolean): DeclarationMetrics[] {\n  // `typedef struct Foo { ... } Bar;` declares both the tag `Foo` and the alias `Bar`.\n  const typeNode = node.childForFieldName('type');\n  const declarations = typeNode ? declarationFromNode(typeNode, exported) : [];\n  // The opaque-type idiom `typedef struct X X;` only forward-declares a tag defined elsewhere —\n  // like a function prototype — so its alias must not collide with the tag's definition.\n  const bodylessTagName =\n    typeNode?.type.endsWith('_specifier') && !typeNode.childForFieldName('body')\n      ? typeNode.childForFieldName('name')?.text\n      : undefined;\n  const seenNames = new Set(declarations.map((declaration) => declaration.name));\n  for (const declarator of findChildrenByFieldName(node, 'declarator')) {\n    const name = declarator.type === 'type_identifier' ? declarator.text : unwrapDeclaratorName(declarator);\n    if (name && name !== bodylessTagName && !seenNames.has(name)) {\n      seenNames.add(name);\n      declarations.push({ exported, name, startLine: declarator.startPosition.row + 1 });\n    }\n  }\n  return declarations;\n}\n\nconst cVariableDeclaratorTypes = new Set([\n  'init_declarator',\n  'pointer_declarator',\n  'array_declarator',\n  'reference_declarator',\n  'identifier',\n  // C/C++ struct/class members\n  'field_identifier',\n]);\n\n/**\n * A bare `function_declarator` (`int f(int);`) is a prototype, but one whose name is parenthesized\n * (`int (*fp)(int);`) declares a function-pointer variable. Pointer/reference-returning prototypes\n * (`int *f(void);`) wrap the function declarator and are prototypes all the same.\n */\nfunction isCVariableDeclarator(node: Parser.SyntaxNode): boolean {\n  if (node.type === 'pointer_declarator' || node.type === 'reference_declarator') {\n    let current: Parser.SyntaxNode | null | undefined = node;\n    while (\n      current &&\n      (current.type === 'pointer_declarator' ||\n        current.type === 'reference_declarator' ||\n        current.type === 'array_declarator')\n    ) {\n      current = nextDeclarator(current);\n    }\n    if (current?.type === 'function_declarator') {\n      return current.childForFieldName('declarator')?.type === 'parenthesized_declarator';\n    }\n    return true;\n  }\n\n  if (cVariableDeclaratorTypes.has(node.type)) {\n    return true;\n  }\n\n  return (\n    node.type === 'function_declarator' && node.childForFieldName('declarator')?.type === 'parenthesized_declarator'\n  );\n}\n\n/** `storage_class_specifier` exists only in the C/C++ grammars, so this is language-safe. */\nfunction hasStorageClass(node: Parser.SyntaxNode, keyword: string): boolean {\n  return node.children.some((child) => child.type === 'storage_class_specifier' && child.text === keyword);\n}\n\n/**\n * tree-sitter-cpp has no C++20 module support, so `export module foo;` / `import bar;` misparse as\n * `declaration` nodes whose \"type\" is the keyword; they declare nothing and bind nothing. A file\n * that visibly aliases the name as a type (`typedef int module;`) makes such declarations ordinary\n * variables again — `module`/`import` are keywords only within recognized module directives.\n */\nfunction isMisparsedCppModuleDeclaration(node: Parser.SyntaxNode): boolean {\n  const typeNode = node.childForFieldName('type');\n  if (\n    typeNode?.type !== 'type_identifier' ||\n    (typeNode.text !== 'import' && typeNode.text !== 'export' && typeNode.text !== 'module')\n  ) {\n    return false;\n  }\n  return !hasVisibleTypeAlias(node, typeNode.text);\n}\n\n/** Whether the file typedefs/aliases `name` as a type, disambiguating module-keyword misparses. */\nfunction hasVisibleTypeAlias(node: Parser.SyntaxNode, name: string): boolean {\n  let root = node;\n  while (root.parent) {\n    root = root.parent;\n  }\n  return collectNodes(root, new Set(['type_definition', 'alias_declaration'])).some((definition) => {\n    const declarator = definition.childForFieldName('declarator') ?? definition.childForFieldName('name');\n    return declarator?.text === name;\n  });\n}\n\n/**\n * Extracts each declared variable from a C/C++ `declaration`. Prototypes intentionally declare no\n * symbol: emitting them would pair every header prototype with its definition in another file and\n * flood cross-file duplicate-symbol groups.\n */\nfunction declarationsFromCDeclaration(node: Parser.SyntaxNode, exported: boolean, isCpp = false): DeclarationMetrics[] {\n  if ((isCpp && isMisparsedCppModuleDeclaration(node)) || hasStorageClass(node, 'static')) {\n    return [];\n  }\n  // `struct Foo { int x; } value;` defines the tag `Foo` alongside the variable; body-less type\n  // references (`struct Foo value;`) are rejected by declarationFromNode's body check.\n  const typeNode = node.childForFieldName('type');\n  const declarations = typeNode ? declarationFromNode(typeNode, exported) : [];\n  const seenNames = new Set(declarations.map((declaration) => declaration.name));\n  const isExtern = hasStorageClass(node, 'extern');\n  for (const child of node.namedChildren.filter(isCVariableDeclarator)) {\n    // A non-initializing `extern` declarator only re-declares a symbol defined elsewhere — like a\n    // prototype — and must not collide with that definition in symbol groups.\n    if (isExtern && child.type !== 'init_declarator') {\n      continue;\n    }\n    // C++ (unlike C) gives namespace-scope const variables internal linkage unless they are\n    // extern, inline, or references, so they are file-local rather than cross-file symbols.\n    if (\n      isCpp &&\n      !isExtern &&\n      !hasStorageClass(node, 'inline') &&\n      !declaratorChainContainsReference(child) &&\n      !isCMutableBinding(node, child)\n    ) {\n      continue;\n    }\n    const name = unwrapDeclaratorName(child);\n    if (name && !seenNames.has(name)) {\n      seenNames.add(name);\n      declarations.push({ exported, name, startLine: child.startPosition.row + 1 });\n    }\n  }\n  return declarations;\n}\n\nfunction declaratorChainContainsReference(declarator: Parser.SyntaxNode): boolean {\n  let current: Parser.SyntaxNode | null | undefined =\n    declarator.type === 'init_declarator' ? (declarator.childForFieldName('declarator') ?? declarator) : declarator;\n  while (current) {\n    if (current.type === 'reference_declarator') {\n      return true;\n    }\n    current = nextDeclarator(current);\n  }\n  return false;\n}\n\nfunction declarationFromNode(node: Parser.SyntaxNode, exported: boolean): DeclarationMetrics[] {\n  // C/C++ `struct Foo;`-style forward declarations reuse the declaration node type; only\n  // definitions with a body declare a module-level symbol.\n  if (!isTopLevelDeclarationNode(node) || (node.type.endsWith('_specifier') && !node.childForFieldName('body'))) {\n    return [];\n  }\n\n  // C/C++ `static` gives internal linkage: the symbol is file-local, not a cross-file module symbol.\n  if (hasStorageClass(node, 'static')) {\n    return [];\n  }\n\n  // C/C++ enumerators are constants declared in the surrounding scope; scoped-enum (`enum class`)\n  // members are qualified by the enum name instead.\n  if (node.type === 'enum_specifier') {\n    return declarationsFromEnumSpecifier(node, exported);\n  }\n\n  const name = findDeclarationName(node);\n  return name ? [{ exported, name, startLine: node.startPosition.row + 1 }] : [];\n}\n\nfunction declarationsFromEnumSpecifier(node: Parser.SyntaxNode, exported: boolean): DeclarationMetrics[] {\n  const declarations: DeclarationMetrics[] = [];\n  const tagName = node.childForFieldName('name')?.text;\n  if (tagName) {\n    declarations.push({ exported, name: tagName, startLine: node.startPosition.row + 1 });\n  }\n  const isScoped = node.children.some((child) => !child.isNamed && (child.text === 'class' || child.text === 'struct'));\n  for (const enumerator of node.childForFieldName('body')?.namedChildren ?? []) {\n    if (enumerator.type !== 'enumerator') {\n      continue;\n    }\n    const name = enumerator.childForFieldName('name')?.text;\n    if (name) {\n      declarations.push({\n        exported,\n        name: isScoped && tagName ? `${tagName}::${name}` : name,\n        startLine: enumerator.startPosition.row + 1,\n      });\n    }\n  }\n  return declarations;\n}\n\nfunction findDeclarationName(node: Parser.SyntaxNode): string | undefined {\n  if (node.type === 'method_declaration' && node.childForFieldName('receiver')) {\n    return findGoMethodDeclarationName(node);\n  }\n\n  let nameNode = node.childForFieldName('name');\n  // C++ class/struct template specializations name the type via a `template_type` wrapper\n  // (`template<> class Box<int>`); the unqualified inner name keeps specializations in the same\n  // symbol group as the primary template.\n  if (nameNode?.type === 'template_type') {\n    nameNode = nameNode.childForFieldName('name');\n  }\n  // Ruby `class A::B` names the type via `scope_resolution`; keep the qualified `A::B` so same-named\n  // types under different namespaces stay distinct in symbol groups.\n  if (nameNode?.type === 'scope_resolution') {\n    return nameNode.text;\n  }\n  if (nameNode) {\n    return isDeclarationNameNode(nameNode) ? nameNode.text : undefined;\n  }\n\n  // C/C++ function definitions name the function inside the declarator chain; this must run before\n  // the generic fallback, which would otherwise pick up the return type's `type_identifier`.\n  const declaratorName = unwrapDeclaratorName(node.childForFieldName('declarator'), true);\n  if (declaratorName) {\n    return declaratorName;\n  }\n\n  return node.namedChildren.find(isDeclarationNameNode)?.text;\n}\n\nfunction isModuleExportNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'export_statement' || node.type === 'export_declaration';\n}\n\nfunction isDeclarationContainer(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'lexical_declaration' ||\n    node.type === 'variable_declaration' ||\n    node.type === 'decorated_definition' ||\n    node.type === 'type_declaration' ||\n    node.type === 'const_declaration' ||\n    node.type === 'var_declaration' ||\n    node.type === 'var_spec_list' ||\n    // C/C++ wrappers around top-level symbols (namespaces are handled separately to thread their\n    // scope); declarations in inactive preprocessor arms are still collected, which is the norm\n    // for un-preprocessed analysis.\n    node.type === 'linkage_specification' ||\n    node.type === 'template_declaration' ||\n    node.type === 'declaration_list' ||\n    node.type === 'preproc_ifdef' ||\n    node.type === 'preproc_if' ||\n    node.type === 'preproc_else' ||\n    node.type === 'preproc_elif'\n  );\n}\n\nfunction isTopLevelDeclarationNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'function_declaration' ||\n    node.type === 'function_definition' ||\n    node.type === 'function_item' ||\n    node.type === 'method_declaration' ||\n    node.type === 'class_declaration' ||\n    node.type === 'class_definition' ||\n    node.type === 'interface_declaration' ||\n    node.type === 'type_alias_declaration' ||\n    node.type === 'type_declaration' ||\n    node.type === 'type_spec' ||\n    node.type === 'const_spec' ||\n    node.type === 'var_spec' ||\n    node.type === 'variable_declarator' ||\n    node.type === 'struct_item' ||\n    node.type === 'enum_item' ||\n    node.type === 'union_item' ||\n    node.type === 'trait_item' ||\n    node.type === 'type_item' ||\n    node.type === 'const_item' ||\n    node.type === 'static_item' ||\n    node.type === 'mod_item' ||\n    // Java\n    node.type === 'enum_declaration' ||\n    node.type === 'record_declaration' ||\n    node.type === 'annotation_type_declaration' ||\n    // Ruby (keyword-like node types exist only in the Ruby grammar as named nodes; in other\n    // grammars a top-level `class`/`method` never appears as a direct named child of the root)\n    node.type === 'method' ||\n    node.type === 'singleton_method' ||\n    node.type === 'class' ||\n    node.type === 'module' ||\n    // C/C++ (body-less forward declarations are filtered in declarationFromNode)\n    node.type === 'alias_declaration' ||\n    node.type === 'struct_specifier' ||\n    node.type === 'class_specifier' ||\n    node.type === 'enum_specifier' ||\n    node.type === 'union_specifier'\n  );\n}\n\nfunction isDeclarationNameNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'identifier' ||\n    node.type === 'type_identifier' ||\n    node.type === 'property_identifier' ||\n    node.type === 'field_identifier' ||\n    // Ruby classes/modules are named by a `constant`.\n    node.type === 'constant'\n  );\n}\n\nfunction collectExportedNames(root: Parser.SyntaxNode): Set<string> {\n  const exportedNames = new Set<string>();\n\n  function visit(node: Parser.SyntaxNode, insideSourcedExport: boolean): void {\n    if (!insideSourcedExport && isExportSpecifierNode(node)) {\n      const name = findExportedName(node);\n      if (name) {\n        exportedNames.add(name);\n      }\n    }\n\n    const isSourcedExport =\n      insideSourcedExport || (isModuleExportNode(node) && node.childForFieldName('source') !== null);\n    for (const child of node.namedChildren) {\n      visit(child, isSourcedExport);\n    }\n  }\n\n  visit(root, false);\n  return exportedNames;\n}\n\nfunction isExportSpecifierNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'export_specifier' || node.type === 'namespace_export';\n}\n\nfunction findExportedName(node: Parser.SyntaxNode): string | undefined {\n  const nameNode =\n    node.childForFieldName('name') ?? node.childForFieldName('alias') ?? node.namedChildren.find(isDeclarationNameNode);\n  return nameNode && isDeclarationNameNode(nameNode) ? nameNode.text : undefined;\n}\n\nfunction findGoMethodDeclarationName(node: Parser.SyntaxNode): string | undefined {\n  const nameNode = node.childForFieldName('name');\n  const receiverTypeNode = node.childForFieldName('receiver')?.namedChildren[0]?.childForFieldName('type');\n  if (!nameNode || !isDeclarationNameNode(nameNode) || !receiverTypeNode) {\n    return nameNode && isDeclarationNameNode(nameNode) ? nameNode.text : undefined;\n  }\n\n  return `${normalizeGoReceiverType(receiverTypeNode.text)}.${nameNode.text}`;\n}\n\nfunction normalizeGoReceiverType(receiverType: string): string {\n  return receiverType.replaceAll(/\\s+/gu, '').replace(/^\\*+/u, '');\n}\n\nfunction measureCoupling(root: Parser.SyntaxNode, language: LanguageDefinition): CouplingMetrics {\n  const importSources = new Set<string>();\n  let importCount = 0;\n  let exportCount = 0;\n\n  function visit(node: Parser.SyntaxNode): void {\n    // Go nests import_spec inside import_spec_list inside import_declaration; only the leaf spec\n    // is one import, or the block would count 2-4x.\n    const isGoImportWrapper =\n      language.name === 'go' && (node.type === 'import_declaration' || node.type === 'import_spec_list');\n    if (\n      !isGoImportWrapper &&\n      (isImportNode(node) ||\n        isRustModDeclaration(node, language) ||\n        isCppModuleImport(node, language) ||\n        isDynamicImportNode(node) ||\n        isRubyRequireCall(node, language))\n    ) {\n      importCount += 1;\n    }\n\n    if (isImportSourceNode(node, language)) {\n      for (const source of findImportSources(node, language, { expandPythonSubmodules: false })) {\n        importSources.add(source);\n      }\n    }\n\n    if (isExportNode(node)) {\n      exportCount += 1;\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n\n  const relativeImportCount = [...importSources].filter((source) =>\n    isRelativeImportSource(source, language.name)\n  ).length;\n\n  return {\n    importCount,\n    importSourceCount: importSources.size,\n    relativeImportCount,\n    externalImportCount: importSources.size - relativeImportCount,\n    exportCount,\n  };\n}\n\nfunction measureSyntaxFeatures(root: Parser.SyntaxNode, languageName: string): SyntaxFeatureMetrics {\n  const metrics: SyntaxFeatureMetrics = {\n    assignmentCount: 0,\n    awaitExpressionCount: 0,\n    loopStatementCount: 0,\n    mutableBindingCount: 0,\n    returnStatementCount: 0,\n    throwStatementCount: 0,\n    tryStatementCount: 0,\n  };\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (isAssignmentNode(node)) {\n      metrics.assignmentCount += 1;\n    }\n    if (isAwaitNode(node)) {\n      metrics.awaitExpressionCount += 1;\n    }\n    if (isLoopNode(node)) {\n      metrics.loopStatementCount += 1;\n    }\n    metrics.mutableBindingCount += countMutableBindings(node, languageName);\n    if (isReturnNode(node)) {\n      metrics.returnStatementCount += 1;\n    }\n    if (isThrowNode(node)) {\n      metrics.throwStatementCount += 1;\n    }\n    if (isTryNode(node)) {\n      metrics.tryStatementCount += 1;\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return metrics;\n}\n\nfunction isAssignmentNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'assignment_expression' ||\n    node.type === 'augmented_assignment_expression' ||\n    node.type === 'assignment_statement' ||\n    node.type === 'assignment' ||\n    node.type === 'augmented_assignment' ||\n    node.type === 'operator_assignment' ||\n    node.type === 'short_var_declaration' ||\n    node.type === 'compound_assignment_expr' ||\n    // Python's walrus (`if (n := len(xs)):`) binds like an assignment.\n    node.type === 'named_expression' ||\n    // Increment/decrement mutate their operand: JS/TS/Java/C/C++ `i++`, Go `i++`/`i--` statements.\n    node.type === 'update_expression' ||\n    node.type === 'inc_statement' ||\n    node.type === 'dec_statement'\n  );\n}\n\nfunction isAwaitNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'await_expression' || node.type === 'await' || node.type === 'co_await_expression';\n}\n\nfunction isLoopNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'for_statement' ||\n    node.type === 'for_in_statement' ||\n    node.type === 'enhanced_for_statement' ||\n    node.type === 'for_range_loop' ||\n    node.type === 'while_statement' ||\n    node.type === 'do_statement' ||\n    node.type === 'for_expression' ||\n    node.type === 'while_expression' ||\n    node.type === 'loop_expression' ||\n    // Ruby loop nodes are keyword-named; only named nodes reach this check.\n    node.type === 'while' ||\n    node.type === 'until' ||\n    node.type === 'for' ||\n    node.type === 'while_modifier' ||\n    node.type === 'until_modifier'\n  );\n}\n\n/**\n * Java and C/C++ declare several bindings per statement, so each mutable declarator counts. The\n * C/C++ branches are language-gated because `field_declaration` is a shared node type: Go and\n * Rust struct fields would otherwise count as mutable bindings.\n */\nfunction countMutableBindings(node: Parser.SyntaxNode, languageName: string): number {\n  const isC = languageName === 'c' || languageName === 'cpp';\n  if (node.type === 'local_variable_declaration' || (node.type === 'field_declaration' && languageName === 'java')) {\n    const javaDeclarators = node.namedChildren.filter((child) => child.type === 'variable_declarator');\n    return isJavaMutableDeclaration(node) ? javaDeclarators.length : 0;\n  }\n\n  if (isC && (node.type === 'declaration' || node.type === 'field_declaration')) {\n    return countCMutableBindings(node, languageName === 'cpp');\n  }\n\n  // tree-sitter-cpp parses the in-class `int count = 0;` member as a pure-virtual-like\n  // `function_definition` whose declarator is a bare field name; real functions have a\n  // `function_declarator` and stay excluded.\n  if (isC && node.type === 'function_definition') {\n    const declarator = node.childForFieldName('declarator');\n    if (declarator?.type === 'field_identifier' || declarator?.type === 'identifier') {\n      return countCMutableBindings(node, languageName === 'cpp');\n    }\n    return 0;\n  }\n\n  // Java `for (String x : xs)` binds its loop variable directly on the statement node.\n  if (node.type === 'enhanced_for_statement') {\n    return isJavaMutableDeclaration(node) ? 1 : 0;\n  }\n\n  // Java pattern variables (`o instanceof String s`, `case String s ->`, record-pattern\n  // components) are reassignable local variables unless final (JLS 4.12.4). `final` appears as an\n  // anonymous keyword leaf on the pattern, not inside a `modifiers` node.\n  if (\n    languageName === 'java' &&\n    (node.type === 'instanceof_expression' || node.type === 'type_pattern' || node.type === 'record_pattern_component')\n  ) {\n    const bindsName =\n      node.type === 'instanceof_expression'\n        ? node.childForFieldName('name') !== null\n        : node.namedChildren.some((child) => child.type === 'identifier');\n    const isFinal = node.children.some((child) => !child.isNamed && child.text === 'final');\n    return bindsName && !isFinal ? 1 : 0;\n  }\n\n  // C++ `for (int x : xs)` binds directly in the loop's declarator field.\n  if (isC && node.type === 'for_range_loop') {\n    const declarator = node.childForFieldName('declarator');\n    return declarator && isCMutableBinding(node, declarator) ? countCBoundIdentifiers(declarator) : 0;\n  }\n\n  return isMutableBindingNode(node) ? 1 : 0;\n}\n\nfunction countCMutableBindings(node: Parser.SyntaxNode, isCpp: boolean): number {\n  // The module-syntax misparse only exists in the C++ grammar; in C, `module` is an identifier.\n  if (isCpp && isMisparsedCppModuleDeclaration(node)) {\n    return 0;\n  }\n  return sum(\n    node.namedChildren\n      .filter((child) => isCVariableDeclarator(child) && isCMutableBinding(node, child))\n      .map(countCBoundIdentifiers)\n  );\n}\n\n/** A C++ structured binding (`auto [a, b] = ...`) introduces one binding per bound identifier. */\nfunction countCBoundIdentifiers(declarator: Parser.SyntaxNode): number {\n  const inner =\n    declarator.type === 'init_declarator' ? (declarator.childForFieldName('declarator') ?? declarator) : declarator;\n  if (inner.type === 'structured_binding_declarator') {\n    return Math.max(1, inner.namedChildren.filter((child) => child.type === 'identifier').length);\n  }\n  return 1;\n}\n\nfunction isMutableBindingNode(node: Parser.SyntaxNode): boolean {\n  return (\n    (node.type === 'lexical_declaration' && node.firstChild?.text === 'let') ||\n    (node.type === 'variable_declaration' && node.firstChild?.text === 'var') ||\n    node.type === 'var_declaration' ||\n    (node.type === 'let_declaration' && hasRustMutableLetBinding(node))\n  );\n}\n\n/** Java variable/field declarations bind mutably unless marked `final`. */\nfunction isJavaMutableDeclaration(node: Parser.SyntaxNode): boolean {\n  const modifiers = node.namedChildren.find((child) => child.type === 'modifiers');\n  return !modifiers?.children.some((child) => child.text === 'final');\n}\n\n/**\n * A base-type `const` (`const int x`) freezes a plain binding but not a pointer binding\n * (`const int *p` leaves `p` reassignable), while a pointer-level `const` on the level that\n * directly declares the name (`int * const p`, `int ** const s`) freezes it; `volatile` and\n * `restrict` never do.\n */\nfunction isCMutableBinding(declaration: Parser.SyntaxNode, declarator: Parser.SyntaxNode): boolean {\n  let current =\n    declarator.type === 'init_declarator' ? (declarator.childForFieldName('declarator') ?? declarator) : declarator;\n  let insidePointer = false;\n  while (\n    current.type === 'reference_declarator' ||\n    current.type === 'pointer_declarator' ||\n    current.type === 'array_declarator' ||\n    current.type === 'parenthesized_declarator' ||\n    current.type === 'function_declarator'\n  ) {\n    // A C++ reference binding can never be reseated, so it is immutable regardless of qualifiers;\n    // references can nest under pointers (`int *&rp`), so the whole chain is checked.\n    if (current.type === 'reference_declarator') {\n      return false;\n    }\n    const inner = nextDeclarator(current);\n    if (!inner) {\n      break;\n    }\n    if (current.type === 'pointer_declarator') {\n      insidePointer = true;\n      // `const` on the pointer level that owns the name freezes the binding even when array or\n      // function wrappers sit between the pointer and the name (`int * const a[3]`).\n      if (hasConstQualifier(current) && !declaratorChainContainsPointer(inner)) {\n        return false;\n      }\n    }\n    current = inner;\n  }\n\n  return insidePointer || !hasConstQualifier(declaration);\n}\n\nfunction declaratorChainContainsPointer(declarator: Parser.SyntaxNode): boolean {\n  let current: Parser.SyntaxNode | null | undefined = declarator;\n  while (current) {\n    if (current.type === 'pointer_declarator') {\n      return true;\n    }\n    current = nextDeclarator(current);\n  }\n  return false;\n}\n\nfunction hasConstQualifier(node: Parser.SyntaxNode): boolean {\n  return node.namedChildren.some(\n    (child) => child.type === 'type_qualifier' && (child.text === 'const' || child.text === 'constexpr')\n  );\n}\n\n/**\n * A Rust `let` binds mutably via a direct `mut` (`let mut x = ...`) or a `mut` inside its\n * destructuring pattern — a `mut_pattern` (`let (mut a, b) = ...`) or a shorthand `field_pattern`\n * (`let Point { mut x } = ...`). Only the pattern is inspected so a borrow in the value such as\n * `let x = &mut y;` is not miscounted, and a `mut` under a `reference_pattern` (`let &mut x = y;`,\n * which binds `x` immutably) is excluded.\n */\nfunction hasRustMutableLetBinding(node: Parser.SyntaxNode): boolean {\n  if (node.children.some((child) => child.type === 'mutable_specifier')) {\n    return true;\n  }\n\n  const pattern = node.childForFieldName('pattern');\n  if (!pattern) {\n    return false;\n  }\n\n  return pattern\n    .descendantsOfType('mutable_specifier')\n    .some((specifier) => specifier.parent?.type !== 'reference_pattern');\n}\n\nfunction isReturnNode(node: Parser.SyntaxNode): boolean {\n  // Ruby's named `return` node is safe here: the visitor walks named children only, so the\n  // anonymous `return` keyword leaf is never seen. `co_return` is the only way a C++ coroutine\n  // returns; `co_yield` suspends like a generator yield and is not a return.\n  return (\n    node.type === 'return_statement' ||\n    node.type === 'return_expression' ||\n    node.type === 'return' ||\n    node.type === 'co_return_statement'\n  );\n}\n\nfunction isThrowNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'throw_statement' || node.type === 'raise_statement' || isRubyRaiseCall(node);\n}\n\n/** Ruby raises via receiverless `raise`/`fail` calls; a receiver call like `object.raise` is not one. */\nfunction isRubyRaiseCall(node: Parser.SyntaxNode): boolean {\n  if (node.type !== 'call' || node.childForFieldName('receiver')) {\n    return false;\n  }\n\n  const methodNode = node.childForFieldName('method');\n  return methodNode?.type === 'identifier' && (methodNode.text === 'raise' || methodNode.text === 'fail');\n}\n\nfunction isTryNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'try_statement' ||\n    node.type === 'try_with_resources_statement' ||\n    // Ruby's `risky_call rescue fallback` modifier protects an expression like a one-clause begin.\n    node.type === 'rescue_modifier' ||\n    isRubyRescueConstruct(node)\n  );\n}\n\n/**\n * Ruby protects code with `rescue` clauses directly under an explicit `begin` or an implicit\n * method/block `body_statement`; counting the construct (not each clause) matches try-statement\n * counting in other languages.\n */\nfunction isRubyRescueConstruct(node: Parser.SyntaxNode): boolean {\n  // `ensure`-only constructs (`begin ... ensure ... end`) handle exceptions like try/finally.\n  return (\n    (node.type === 'begin' || node.type === 'body_statement') &&\n    node.namedChildren.some((child) => child.type === 'rescue' || child.type === 'ensure')\n  );\n}\n\n/** Caps the pairwise overlap computation so files with thousands of functions stay fast. */\nconst maxCohesionPairCount = 250_000;\n\nfunction measureCohesion(analyses: FunctionAnalysis[]): CohesionMetrics {\n  // An identifier is shared iff it appears in at least two functions, so a frequency map computes\n  // both identifier counts exactly without enumerating function pairs.\n  const functionCountByIdentifier = new Map<string, number>();\n  for (const analysis of analyses) {\n    for (const identifier of analysis.identifiers) {\n      functionCountByIdentifier.set(identifier, (functionCountByIdentifier.get(identifier) ?? 0) + 1);\n    }\n  }\n  let sharedIdentifierCount = 0;\n  for (const count of functionCountByIdentifier.values()) {\n    if (count >= 2) {\n      sharedIdentifierCount += 1;\n    }\n  }\n\n  // The average pairwise Jaccard overlap is quadratic in the function count, so beyond the cap it\n  // is estimated from an evenly strided, deterministic sample of pairs. Sampled linear pair\n  // indexes are converted to (left, right) by walking triangular rows, so the traversal cost is\n  // O(sample + functions) rather than all n(n-1)/2 pairs.\n  const functionCount = analyses.length;\n  const totalPairCount = (functionCount * (functionCount - 1)) / 2;\n  const stride = Math.max(1, Math.ceil(totalPairCount / maxCohesionPairCount));\n  let overlapTotal = 0;\n  let sampledPairCount = 0;\n  let leftIndex = 0;\n  let rowStartPairIndex = 0;\n  let rowLength = functionCount - 1;\n  for (let pairIndex = 0; pairIndex < totalPairCount; pairIndex += stride) {\n    while (pairIndex >= rowStartPairIndex + rowLength) {\n      rowStartPairIndex += rowLength;\n      leftIndex += 1;\n      rowLength = functionCount - 1 - leftIndex;\n    }\n    const rightIndex = leftIndex + 1 + (pairIndex - rowStartPairIndex);\n\n    const left = analyses[leftIndex];\n    const right = analyses[rightIndex];\n    if (!left || !right) {\n      continue;\n    }\n\n    const intersectionSize = countIntersection(left.identifiers, right.identifiers);\n    const unionSize = left.identifiers.size + right.identifiers.size - intersectionSize;\n    overlapTotal += unionSize === 0 ? 0 : intersectionSize / unionSize;\n    sampledPairCount += 1;\n  }\n\n  return {\n    averageFunctionIdentifierOverlap: sampledPairCount === 0 ? 1 : overlapTotal / sampledPairCount,\n    sharedIdentifierCount,\n    uniqueIdentifierCount: functionCountByIdentifier.size,\n  };\n}\n\nfunction measureTypeComplexity(root: Parser.SyntaxNode): TypeComplexityMetrics {\n  const metrics: TypeComplexityMetrics = {\n    typeAnnotationCount: 0,\n    typeAliasCount: 0,\n    interfaceCount: 0,\n    genericParameterCount: 0,\n    unionTypeCount: 0,\n    intersectionTypeCount: 0,\n    conditionalTypeCount: 0,\n    typeAssertionCount: 0,\n    nonNullAssertionCount: 0,\n    satisfiesExpressionCount: 0,\n  };\n\n  function visit(node: Parser.SyntaxNode): void {\n    switch (node.type) {\n      case 'type_annotation': {\n        metrics.typeAnnotationCount += 1;\n        break;\n      }\n      case 'type_alias_declaration': {\n        metrics.typeAliasCount += 1;\n        break;\n      }\n      case 'interface_declaration': {\n        metrics.interfaceCount += 1;\n        break;\n      }\n      case 'type_parameters':\n      case 'type_parameter': {\n        metrics.genericParameterCount += node.type === 'type_parameter' ? 1 : 0;\n        break;\n      }\n      case 'union_type': {\n        metrics.unionTypeCount += 1;\n        break;\n      }\n      case 'intersection_type': {\n        metrics.intersectionTypeCount += 1;\n        break;\n      }\n      case 'conditional_type': {\n        metrics.conditionalTypeCount += 1;\n        break;\n      }\n      case 'as_expression':\n      case 'type_assertion': {\n        metrics.typeAssertionCount += 1;\n        break;\n      }\n      case 'non_null_expression': {\n        metrics.nonNullAssertionCount += 1;\n        break;\n      }\n      case 'satisfies_expression': {\n        metrics.satisfiesExpressionCount += 1;\n        break;\n      }\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return metrics;\n}\n\n/**\n * 1-based numbers of lines that are neither blank nor comment-only, matching measureLines'\n * classification so duplication line coverage and its code-line denominator agree.\n */\nfunction classifyLines(\n  code: string,\n  root: Parser.SyntaxNode\n): { lines: CodeMetrics['lines']; codeLineNumbers: Set<number> } {\n  const sourceLines = code.length === 0 ? [] : code.split(/\\r\\n|\\n|\\r/);\n  // Spans are bucketed by line so classification stays linear; scanning every span per line made\n  // this pass quadratic on comment-heavy files.\n  const commentSpansByLine = new Map<number, CommentSpan[]>();\n  for (const span of collectCommentSpans(root)) {\n    const spans = commentSpansByLine.get(span.line) ?? [];\n    spans.push(span);\n    commentSpansByLine.set(span.line, spans);\n  }\n  let blank = 0;\n  let comment = 0;\n  const codeLineNumbers = new Set<number>();\n\n  for (const [index, line] of sourceLines.entries()) {\n    if (line.trim() === '') {\n      blank += 1;\n      continue;\n    }\n    if (isCommentOnlyLine(line, commentSpansByLine.get(index) ?? [])) {\n      comment += 1;\n    } else {\n      codeLineNumbers.add(index + 1);\n    }\n  }\n\n  return {\n    lines: {\n      total: sourceLines.length,\n      code: codeLineNumbers.size,\n      comment,\n      blank,\n    },\n    codeLineNumbers,\n  };\n}\n\nfunction collectCommentSpans(root: Parser.SyntaxNode): CommentSpan[] {\n  const spans: CommentSpan[] = [];\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (node.type === 'comment' || node.type === 'line_comment' || node.type === 'block_comment') {\n      for (let row = node.startPosition.row; row <= node.endPosition.row; row += 1) {\n        spans.push({\n          line: row,\n          startColumn: row === node.startPosition.row ? node.startPosition.column : 0,\n          endColumn: row === node.endPosition.row ? node.endPosition.column : Number.POSITIVE_INFINITY,\n        });\n      }\n    }\n\n    for (const child of node.namedChildren) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n  return spans;\n}\n\nfunction isCommentOnlyLine(line: string, relevantSpans: CommentSpan[]): boolean {\n  if (relevantSpans.length === 0) {\n    return false;\n  }\n\n  // A line may hold several comments (`/* one */ /* two */`), so every non-whitespace column must\n  // be covered by the UNION of spans, not by a single span.\n  for (let column = 0; column < line.length; column += 1) {\n    if (/\\s/u.test(line[column] ?? ' ')) {\n      continue;\n    }\n    if (!relevantSpans.some((span) => span.startColumn <= column && column < span.endColumn)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction measureHalstead(root: Parser.SyntaxNode, code: string): HalsteadMetrics {\n  const operators = new Map<string, number>();\n  const operands = new Map<string, number>();\n\n  function visit(node: Parser.SyntaxNode): void {\n    if (node.type === 'comment' || node.type === 'line_comment' || node.type === 'block_comment') {\n      return;\n    }\n\n    if (atomicOperandNodeTypes.has(node.type)) {\n      incrementCount(operands, code.slice(node.startIndex, node.endIndex));\n      return;\n    }\n\n    // Operators are counted from leaf tokens only: keyword-named nodes (Ruby `return`, Python\n    // `await`, ...) always contain a same-text anonymous keyword leaf, so counting the named node\n    // as well would double-count.\n    if (node.childCount === 0) {\n      const text = code.slice(node.startIndex, node.endIndex);\n      // Operands win over text matches so identifiers spelled like word operators (`cache.delete(...)`,\n      // a Go parameter named `in`) stay operands; genuine keyword operators are anonymous leaves whose\n      // types are never operand types. A blanket `isNamed` guard would break JS's named `optional_chain`.\n      if (operandNodeTypes.has(node.type)) {\n        incrementCount(operands, text);\n      } else if ((operatorTexts.has(text) || operatorTexts.has(node.type)) && isCountableContextualToken(node, text)) {\n        incrementCount(operators, text || node.type);\n      }\n      return;\n    }\n\n    for (const child of node.children) {\n      visit(child);\n    }\n  }\n\n  visit(root);\n\n  const distinctOperators = operators.size;\n  const distinctOperands = operands.size;\n  const totalOperators = sum(operators.values());\n  const totalOperands = sum(operands.values());\n  const vocabulary = distinctOperators + distinctOperands;\n  const length = totalOperators + totalOperands;\n  const volume = vocabulary === 0 ? 0 : length * Math.log2(vocabulary);\n  const difficulty = distinctOperands === 0 ? 0 : (distinctOperators / 2) * (totalOperands / distinctOperands);\n  const effort = difficulty * volume;\n\n  return {\n    distinctOperators,\n    distinctOperands,\n    totalOperators,\n    totalOperands,\n    vocabulary,\n    length,\n    volume,\n    difficulty,\n    effort,\n    time: effort / 18,\n    bugs: volume / 3000,\n  };\n}\n\nfunction findFunctionName(node: Parser.SyntaxNode): string | undefined {\n  const wrappedName = findWrappedComponentName(node);\n  if (wrappedName) {\n    return wrappedName;\n  }\n\n  const nameNode = node.childForFieldName('name');\n  if (nameNode) {\n    return nameNode.text;\n  }\n\n  // C/C++ definitions name the function inside the (possibly pointer-wrapped) declarator chain.\n  const declaratorName = findDeclaratorName(node);\n  if (declaratorName) {\n    return declaratorName;\n  }\n\n  const parent = node.parent;\n  if (!parent) {\n    return undefined;\n  }\n\n  // A Rust closure bound to a simple `let` identifier (`let add = |x| ...;`) takes that identifier\n  // as its name, mirroring how JS arrow functions assigned to a variable are named, so calls to the\n  // binding resolve as intra-file edges.\n  if (node.type === 'closure_expression' && parent.type === 'let_declaration') {\n    const patternNode = parent.childForFieldName('pattern');\n    return patternNode?.type === 'identifier' ? patternNode.text : undefined;\n  }\n\n  // A C++ lambda assigned to a variable (`auto f = [](int x) { ... };`) takes the variable name,\n  // like Rust `let` closures above, so calls to the binding resolve as intra-file edges.\n  if (node.type === 'lambda_expression' && parent.type === 'init_declarator') {\n    return unwrapDeclaratorName(parent.childForFieldName('declarator'));\n  }\n\n  // A Go func literal bound via `add := func...` or `var add = func...` takes the identifier at\n  // the same list position; unpaired or non-identifier targets stay unnamed.\n  if (node.type === 'func_literal' && parent.type === 'expression_list') {\n    return findGoFuncLiteralName(node, parent);\n  }\n\n  // Ruby lambdas assigned to a name (`choose = ->(x) {...}` / `ADD = lambda { ... }`) take that\n  // name; Ruby assignments use the `left` field, and `lambda { }` blocks hang off a `call`.\n  if (node.type === 'lambda' && parent.type === 'assignment') {\n    return findRubyAssignmentName(parent);\n  }\n  if ((node.type === 'block' || node.type === 'do_block') && isRubyLambdaCall(parent)) {\n    return parent.parent?.type === 'assignment' ? findRubyAssignmentName(parent.parent) : undefined;\n  }\n\n  const parentName = parent.childForFieldName('name');\n  return parentName?.text;\n}\n\nfunction findDeclaratorName(node: Parser.SyntaxNode): string | undefined {\n  return unwrapDeclaratorName(node.childForFieldName('declarator'));\n}\n\n/**\n * Unwraps a C/C++ declarator chain to the declared name, handling parenthesized declarators\n * (function pointers), qualified names, destructors, and operator overloads explicitly; a\n * rightmost-identifier fallback would pick up parameter names from nested `function_declarator`s.\n * With `qualified`, out-of-line scopes are kept with `::` (`Foo::process` stays `Foo::process`,\n * matching namespace qualification so both spellings of a symbol group together; unlike Go's\n * `Receiver.Method` declarations) so same-named methods of different types do not collide in\n * cross-file duplicate-symbol groups; call-graph names stay unqualified so callee matching works.\n */\nfunction unwrapDeclaratorName(declarator: Parser.SyntaxNode | null, qualified = false): string | undefined {\n  let current: Parser.SyntaxNode | null | undefined = declarator;\n  let scopePrefix = '';\n  while (current) {\n    switch (current.type) {\n      case 'identifier':\n      case 'field_identifier':\n      case 'type_identifier':\n      case 'destructor_name':\n      case 'operator_name': {\n        return scopePrefix ? `${scopePrefix}::${current.text}` : current.text;\n      }\n      // A C++ conversion operator (`operator int()`) is its own declarator node whose text spans\n      // the parameter list and qualifiers; only `operator <type>` is the name.\n      case 'operator_cast': {\n        const name = `operator ${current.childForFieldName('type')?.text ?? ''}`.trimEnd();\n        return scopePrefix ? `${scopePrefix}::${name}` : name;\n      }\n      // Template specializations (`id<int>`) and qualified names both carry a `name` field.\n      case 'template_function': {\n        current = current.childForFieldName('name');\n        break;\n      }\n      case 'qualified_identifier': {\n        if (qualified) {\n          const scope = current.childForFieldName('scope')?.text.replaceAll(/\\s+/gu, '');\n          if (scope) {\n            scopePrefix = scopePrefix ? `${scopePrefix}::${scope}` : scope;\n          }\n        }\n        current = current.childForFieldName('name');\n        break;\n      }\n      default: {\n        current = nextDeclarator(current);\n      }\n    }\n  }\n  return undefined;\n}\n\n/**\n * Steps into the inner declarator; `reference_declarator` and `parenthesized_declarator` do not\n * expose a `declarator` field in tree-sitter-cpp, so their sole named child is the inner node.\n */\nfunction nextDeclarator(node: Parser.SyntaxNode): Parser.SyntaxNode | undefined {\n  const direct = node.childForFieldName('declarator');\n  if (direct) {\n    return direct;\n  }\n  if (node.type === 'reference_declarator' || node.type === 'parenthesized_declarator') {\n    return node.namedChild(0) ?? undefined;\n  }\n  return undefined;\n}\n\nfunction findRubyAssignmentName(assignment: Parser.SyntaxNode): string | undefined {\n  const leftNode = assignment.childForFieldName('left');\n  return leftNode?.type === 'identifier' || leftNode?.type === 'constant' ? leftNode.text : undefined;\n}\n\nfunction isRubyLambdaCall(node: Parser.SyntaxNode): boolean {\n  if (node.type !== 'call' || node.childForFieldName('receiver')) {\n    return false;\n  }\n  const methodNode = node.childForFieldName('method');\n  return methodNode?.type === 'identifier' && (methodNode.text === 'lambda' || methodNode.text === 'proc');\n}\n\nfunction findGoFuncLiteralName(node: Parser.SyntaxNode, expressionList: Parser.SyntaxNode): string | undefined {\n  const holder = expressionList.parent;\n  // Comments interleave with expressions in the list but have no matching binding target, so\n  // positions are aligned over non-comment children on both sides.\n  const values = expressionList.namedChildren.filter((child) => child.type !== 'comment');\n  const valueIndex = values.findIndex((child) => child.id === node.id);\n  if (!holder || valueIndex === -1) {\n    return undefined;\n  }\n\n  if (holder.type === 'short_var_declaration') {\n    const targets = holder.childForFieldName('left')?.namedChildren.filter((child) => child.type !== 'comment');\n    return asGoBindingName(targets?.[valueIndex]);\n  }\n\n  if (holder.type === 'var_spec') {\n    const target = findChildrenByFieldName(holder, 'name')[valueIndex];\n    return asGoBindingName(target);\n  }\n\n  return undefined;\n}\n\n/** Go's blank identifier `_` discards the value and creates no callable binding. */\nfunction asGoBindingName(target: Parser.SyntaxNode | undefined): string | undefined {\n  return target?.type === 'identifier' && target.text !== '_' ? target.text : undefined;\n}\n\nfunction findWrappedComponentName(node: Parser.SyntaxNode): string | undefined {\n  let current: Parser.SyntaxNode | undefined = node;\n  while (current) {\n    const argumentsNode: Parser.SyntaxNode | null = current.parent;\n    const callNode: Parser.SyntaxNode | null | undefined = argumentsNode?.parent;\n    if (argumentsNode?.type !== 'arguments' || callNode?.type !== 'call_expression') {\n      return undefined;\n    }\n\n    if (!isReactComponentWrapperCall(callNode)) {\n      return undefined;\n    }\n\n    const declaratorNode = callNode.parent;\n    if (declaratorNode?.type === 'variable_declarator') {\n      return declaratorNode.childForFieldName('name')?.text;\n    }\n\n    current = callNode;\n  }\n\n  return undefined;\n}\n\nfunction isReactComponentWrapperCall(node: Parser.SyntaxNode): boolean {\n  const calleeNode = node.childForFieldName('function') ?? node.namedChild(0);\n  return (\n    calleeNode?.text === 'memo' ||\n    calleeNode?.text === 'React.memo' ||\n    calleeNode?.text === 'forwardRef' ||\n    calleeNode?.text === 'React.forwardRef'\n  );\n}\n\nfunction isCallNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'call_expression' ||\n    node.type === 'call' ||\n    node.type === 'method_invocation' ||\n    node.type === 'macro_invocation' ||\n    // Constructor invocations are calls: JS/C++ `new_expression`, Java `object_creation_expression`\n    // and `this(...)`/`super(...)`.\n    node.type === 'new_expression' ||\n    node.type === 'object_creation_expression' ||\n    node.type === 'explicit_constructor_invocation'\n  );\n}\n\n/** Reconstructs `operator+` / `operator int` from tree-sitter-cpp's ERROR-wrapped misparses. */\nfunction findCppExplicitOperatorName(node: Parser.SyntaxNode): string | undefined {\n  // `this->operator+(y)`: the operator_name lands inside an ERROR child of the call itself.\n  for (const child of node.children) {\n    if (child.type === 'ERROR') {\n      const operatorName = child.children.find((grandChild) => grandChild.type === 'operator_name');\n      if (operatorName) {\n        return operatorName.text;\n      }\n    }\n  }\n  // `x.operator int()`: the field_expression holds an ERROR `operator` before the field name.\n  const callee = node.childForFieldName('function');\n  if (callee?.type === 'field_expression') {\n    const errorIndex = callee.children.findIndex((child) => child.type === 'ERROR' && child.text === 'operator');\n    const fieldNode = errorIndex === -1 ? undefined : callee.children[errorIndex + 1];\n    if (fieldNode?.type === 'field_identifier' || fieldNode?.type === 'primitive_type') {\n      return `operator ${fieldNode.text}`;\n    }\n  }\n  return undefined;\n}\n\n/** Function-literal node types across supported grammars whose invocation names no callee. */\nconst anonymousCallableNodeTypes = new Set([\n  'arrow_function', // JS/TS\n  'function_expression', // JS/TS\n  'function', // older JS grammars / Python-style\n  'lambda', // Python, Ruby\n  'lambda_expression', // C++, Java\n  'closure_expression', // Rust\n  'func_literal', // Go\n  'anonymous_function', // misc grammars\n]);\n\nfunction findCalleeName(node: Parser.SyntaxNode): string | undefined {\n  // Java `method_invocation` names its callee `name` and Ruby `call` names it `method`. The\n  // `namedChild(0)` fallback covers Rust `macro_invocation` (whose callee is the `macro` field,\n  // not `function`), so macros resolve to their name. `findRightmostIdentifier` must be kept rather\n  // than reading `calleeNode.text`: member calls like `self.map.get(key)` must resolve to `get`, not\n  // the full `self.map.get`, so intra-file call-graph name matching stays correct.\n  // Ruby lambdas/procs are invoked via `helper.call(...)`; the receiver is the real callee.\n  // `helper[...]` (element_reference) is intentionally NOT treated as a call: it is\n  // indistinguishable from ordinary array/hash indexing and would distort call counts.\n  if (node.type === 'call') {\n    const methodNode = node.childForFieldName('method');\n    const receiverNode = node.childForFieldName('receiver');\n    if (methodNode?.text === 'call' && receiverNode?.type === 'identifier') {\n      return receiverNode.text;\n    }\n    // A Ruby setter send (`self.foo = x`) invokes the method named `foo=`, matching its definition.\n    if (methodNode && node.parent?.type === 'assignment' && node.parent.childForFieldName('left')?.id === node.id) {\n      return `${methodNode.text}=`;\n    }\n    // Explicit operator sends (`self.+(other)`) name the operator method directly.\n    if (methodNode?.type === 'operator') {\n      return methodNode.text;\n    }\n  }\n\n  // tree-sitter-cpp misparses explicit operator calls with ERROR wrappers (`this->operator+(y)`,\n  // `x.operator int()`); reconstruct the definition-style name instead of dropping the callee or\n  // fabricating one from the operand type.\n  if (node.type === 'call_expression') {\n    const operatorName = findCppExplicitOperatorName(node);\n    if (operatorName) {\n      return operatorName;\n    }\n  }\n\n  const calleeNode =\n    node.childForFieldName('function') ??\n    node.childForFieldName('name') ??\n    node.childForFieldName('method') ??\n    // Constructor calls name the constructed type (`constructor` in JS, `type` in Java/C++).\n    node.childForFieldName('constructor') ??\n    node.childForFieldName('type') ??\n    node.namedChild(0);\n  if (!calleeNode) {\n    return undefined;\n  }\n\n  // Immediately invoked anonymous callables (`(() => target)()`, `([](){ ... })()`) have no stable\n  // callee name; searching their body would fabricate an edge to whatever identifier appears last.\n  const unwrappedCallee = unwrapParenthesizedExpression(calleeNode);\n  if (anonymousCallableNodeTypes.has(unwrappedCallee.type)) {\n    return undefined;\n  }\n\n  return findRightmostIdentifier(unwrappedCallee);\n}\n\nfunction unwrapParenthesizedExpression(node: Parser.SyntaxNode): Parser.SyntaxNode {\n  let current = node;\n  while (current.type === 'parenthesized_expression' && current.namedChildCount === 1) {\n    const inner = current.namedChild(0);\n    if (!inner) {\n      break;\n    }\n    current = inner;\n  }\n  return current;\n}\n\n/** Ternary/conditional and Rust try parents make `?` an operator; TS optional markers do not. */\nconst questionOperatorParentTypes = new Set([\n  'ternary_expression',\n  'conditional_expression',\n  'conditional',\n  'try_expression',\n  // TypeScript conditional types (`T extends U ? X : Y`) select like a ternary.\n  'conditional_type',\n]);\n\nfunction isCountableContextualToken(node: Parser.SyntaxNode, text: string): boolean {\n  if (text === '@') {\n    // Python matrix multiplication only; decorator/annotation `@` marks are not operators.\n    const parentType = node.parent?.type;\n    return parentType === 'binary_operator' || parentType === 'augmented_assignment';\n  }\n  if (text !== '?') {\n    return true;\n  }\n  const parentType = node.parent?.type;\n  return parentType !== undefined && questionOperatorParentTypes.has(parentType);\n}\n\nfunction findRightmostIdentifier(node: Parser.SyntaxNode): string | undefined {\n  // Generic-call wrappers (Rust `helper::<T>()`, C++ `helper<T>()`/`obj.get<T>()`) put type\n  // arguments after the callee, so the right-to-left search below would return the type argument;\n  // the callee lives in the `function`/`name` field.\n  if (node.type === 'generic_function' || node.type === 'template_function' || node.type === 'template_method') {\n    const calleeNode = node.childForFieldName('function') ?? node.childForFieldName('name');\n    if (calleeNode) {\n      return findRightmostIdentifier(calleeNode);\n    }\n  }\n\n  // Explicit destructor calls (`x.~Foo()`) must keep the atomic `~Foo` to match their definition.\n  if (node.type === 'destructor_name') {\n    return node.text;\n  }\n\n  // Java `new Box<String>()` names the base type first; the right-to-left search below would\n  // otherwise return the type argument `String`.\n  if (node.type === 'generic_type') {\n    const baseNode = node.namedChildren.find(\n      (child) => child.type === 'type_identifier' || child.type === 'scoped_type_identifier'\n    );\n    if (baseNode) {\n      return findRightmostIdentifier(baseNode);\n    }\n  }\n\n  if (\n    node.type === 'identifier' ||\n    node.type === 'property_identifier' ||\n    node.type === 'field_identifier' ||\n    node.type === 'type_identifier' ||\n    node.type === 'attribute'\n  ) {\n    return node.text;\n  }\n\n  for (let index = node.namedChildCount - 1; index >= 0; index -= 1) {\n    const child = node.namedChild(index);\n    if (!child) {\n      continue;\n    }\n\n    const identifier = findRightmostIdentifier(child);\n    if (identifier) {\n      return identifier;\n    }\n  }\n\n  return undefined;\n}\n\nfunction isReactCreateElementCall(node: Parser.SyntaxNode): boolean {\n  if (!isCallNode(node)) {\n    return false;\n  }\n\n  const calleeNode = node.childForFieldName('function') ?? node.namedChild(0);\n  return calleeNode?.text === 'React.createElement' || calleeNode?.text === 'createElement';\n}\n\nfunction isImportNode(node: Parser.SyntaxNode): boolean {\n  return (\n    node.type === 'import_statement' ||\n    node.type === 'import_declaration' ||\n    node.type === 'import_from_statement' ||\n    node.type === 'import_spec' ||\n    node.type === 'import_spec_list' ||\n    node.type === 'use_declaration' ||\n    node.type === 'extern_crate_declaration' ||\n    // JPMS `requires` directives in module-info.java declare module dependences (JLS 7.7.1).\n    node.type === 'requires_module_directive' ||\n    node.type === 'preproc_include'\n  );\n}\n\nfunction isImportSourceNode(node: Parser.SyntaxNode, language: LanguageDefinition): boolean {\n  return (\n    isImportNode(node) ||\n    isRustModDeclaration(node, language) ||\n    isCppModuleImport(node, language) ||\n    isDynamicImportNode(node) ||\n    isRubyRequireCall(node, language) ||\n    (isExportNode(node) && node.childForFieldName('source') !== null)\n  );\n}\n\n/**\n * C++20 imports misparse without grammar module support: `import name;` as a declaration typed\n * `import`, `export import name;` as one typed `export`, and partition/header-unit forms\n * (`import :part;`, `import \"h.h\";`, `import <vector>;`) as labeled or expression statements.\n */\nfunction isCppModuleImport(node: Parser.SyntaxNode, language: LanguageDefinition): boolean {\n  if (language.name !== 'cpp') {\n    return false;\n  }\n  if (node.type === 'declaration') {\n    const typeNode = node.childForFieldName('type');\n    if (typeNode?.type !== 'type_identifier') {\n      return false;\n    }\n    if (typeNode.text === 'import') {\n      return !hasVisibleTypeAlias(node, 'import');\n    }\n    return typeNode.text === 'export' && /^export\\s+import\\b/u.test(node.text);\n  }\n  if (node.type === 'labeled_statement' || node.type === 'expression_statement') {\n    return node.parent?.type === 'translation_unit' && /^import\\s+[:\"<]/u.test(node.text);\n  }\n  return false;\n}\n\n/** A bodyless `mod name;` declares an out-of-line child module loaded from `name.rs`/`name/mod.rs`. */\nfunction isRustModDeclaration(node: Parser.SyntaxNode, language: LanguageDefinition): boolean {\n  return language.name === 'rust' && node.type === 'mod_item' && !node.childForFieldName('body');\n}\n\nfunction isDynamicImportNode(node: Parser.SyntaxNode): boolean {\n  if (!isCallNode(node)) {\n    return false;\n  }\n\n  const calleeNode = node.childForFieldName('function') ?? node.namedChild(0);\n  return calleeNode?.text === 'import';\n}\n\nfunction findImportSources(\n  node: Parser.SyntaxNode,\n  language: LanguageDefinition,\n  options: { expandPythonSubmodules: boolean }\n): string[] {\n  if (language.name === 'python') {\n    const pythonSources = findPythonImportSources(node, options);\n    if (pythonSources.length > 0) {\n      return pythonSources;\n    }\n  }\n\n  if (language.name === 'rust') {\n    return findRustImportSources(node);\n  }\n\n  // JPMS `requires [transitive|static] module.name;` names the depended-on module.\n  if (language.name === 'java' && node.type === 'requires_module_directive') {\n    const moduleNode = node.childForFieldName('module');\n    return moduleNode ? [normalizeImportSource(moduleNode.text)] : [];\n  }\n\n  if (language.name === 'java' && node.type === 'import_declaration') {\n    const importedPath = node.namedChild(0);\n    if (!importedPath) {\n      return [];\n    }\n    // The `.*` suffix is preserved so wildcard (package) imports stay unresolvable to a single\n    // file. A static wildcard (`import static X.Helper.*`) names one specific type (JLS 7.5.4),\n    // so it resolves like a plain import of that type.\n    const isStatic = node.children.some((child) => child.type === 'static');\n    const isWildcard = node.namedChildren.some((child) => child.type === 'asterisk');\n    const source = normalizeImportSource(importedPath.text);\n    return [isWildcard && !isStatic ? `${source}.*` : source];\n  }\n\n  // The misparsed C++20 module import keeps its source in the node text: a module/partition name,\n  // or a header unit, which resolves like a quoted include (file-relative).\n  if (isCppModuleImport(node, language)) {\n    const match = /^(?:export\\s+)?import\\s+([\\w.:]+|\"[^\"]+\"|<[^>]+>)/u.exec(node.text);\n    const source = match?.[1];\n    if (!source) {\n      return [];\n    }\n    return source.startsWith('\"') ? [`./${unquote(source)}`] : [source];\n  }\n\n  if (isRubyRequireCall(node, language)) {\n    return findRubyRequireSources(node);\n  }\n\n  // C/C++ `#include` paths live in the `path` field as a string literal or `<...>` token. Quoted\n  // includes resolve relative to the including file, unlike `<...>` system includes.\n  if (node.type === 'preproc_include') {\n    const pathNode = node.childForFieldName('path');\n    if (!pathNode) {\n      return [];\n    }\n    const source = unquote(pathNode.text);\n    const isLocal = pathNode.type === 'string_literal' && !source.startsWith('.') && !source.startsWith('/');\n    return [isLocal ? `./${source}` : source];\n  }\n\n  if (isDynamicImportNode(node)) {\n    return findDynamicImportSources(node);\n  }\n\n  const sourceNode = node.childForFieldName('source') ?? findFirstStringNode(node);\n  return sourceNode ? [unquote(sourceNode.text)] : [];\n}\n\nconst rubyRequireMethods = new Set(['require', 'require_relative', 'load']);\n\n/** Only receiverless Kernel-style calls import; `loader.require(...)` is an ordinary method call. */\nfunction isRubyRequireCall(node: Parser.SyntaxNode, language: LanguageDefinition): boolean {\n  if (language.name !== 'ruby' || node.type !== 'call') {\n    return false;\n  }\n\n  const methodNode = node.childForFieldName('method');\n  if (methodNode?.type !== 'identifier') {\n    return false;\n  }\n  // `autoload :User, './user'` registers a `require`; it may carry a module receiver\n  // (`Object.autoload ...`), unlike the receiverless Kernel-style require forms.\n  if (methodNode.text === 'autoload') {\n    const receiver = node.childForFieldName('receiver');\n    return receiver === null || receiver.type === 'constant' || receiver.type === 'scope_resolution';\n  }\n  return node.childForFieldName('receiver') === null && rubyRequireMethods.has(methodNode.text);\n}\n\n/** Resolves `require`/`require_relative`/`load` sources; `require_relative` is always file-relative. */\nfunction findRubyRequireSources(node: Parser.SyntaxNode): string[] {\n  const argumentsNode = node.childForFieldName('arguments');\n  // `autoload :Name, 'path'` names its source in the second argument.\n  const isAutoload = node.childForFieldName('method')?.text === 'autoload';\n  const firstArgument = argumentsNode?.namedChild(isAutoload ? 1 : 0);\n  if (!firstArgument || firstArgument.type !== 'string') {\n    return [];\n  }\n\n  // Dynamic requires (`require \"#{name}\"`) name no static source.\n  if (firstArgument.namedChildren.some((child) => child.type === 'interpolation')) {\n    return [];\n  }\n\n  // Percent literals (`%q(foo)`) keep their delimiters in `text`; the content children are exact.\n  // Escape sequences interleave with content and must be decoded, not dropped.\n  const contentNodes = firstArgument.namedChildren.filter(\n    (child) => child.type === 'string_content' || child.type === 'escape_sequence'\n  );\n  const source =\n    contentNodes.length > 0\n      ? contentNodes\n          .map((child) => (child.type === 'escape_sequence' ? decodeRubyEscapeSequence(child.text) : child.text))\n          .join('')\n      : unquote(firstArgument.text);\n  const isRelative = node.childForFieldName('method')?.text === 'require_relative';\n  if (isRelative) {\n    return [source.startsWith('.') ? source : `./${source}`];\n  }\n  // Plain `require`/`load` resolve `./`/`../` paths against the process CWD, not the requiring\n  // file, so the relative prefix is stripped to keep the source unresolvable as file-relative.\n  return [source.replace(/^(?:\\.\\.?\\/)+/u, '')];\n}\n\nconst rubyEscapeCharacters = new Map([\n  ['n', '\\n'],\n  ['t', '\\t'],\n  ['r', '\\r'],\n  ['s', ' '],\n  ['0', '\\0'],\n]);\n\n/** Decodes a Ruby escape (`\\\\` -> `\\`, `\\/` -> `/`, `\\n` -> newline) inside a require path. */\nfunction decodeRubyEscapeSequence(text: string): string {\n  const escaped = text.slice(1);\n  return rubyEscapeCharacters.get(escaped) ?? escaped;\n}\n\nfunction findDynamicImportSources(node: Parser.SyntaxNode): string[] {\n  const argumentsNode = node.childForFieldName('arguments');\n  const firstArgument = argumentsNode?.namedChild(0);\n  return firstArgument && isStringNode(firstArgument) ? [unquote(firstArgument.text)] : [];\n}\n\nfunction isRelativeImportSource(source: string, language: LanguageName): boolean {\n  if (source.startsWith('.') || source.startsWith('/')) {\n    return true;\n  }\n\n  // `crate`/`self`/`super` are local only in Rust; other languages may legitimately import a module\n  // literally named that, so the in-crate rule must not leak across languages.\n  return language === 'rust' && isRustLocalImportSource(source);\n}\n\n/** Rust in-crate imports address the module tree through `crate`, `self`, or `super`. */\nfunction isRustLocalImportSource(source: string): boolean {\n  return /^(?:crate|self|super)(?:::|$)/u.test(source);\n}\n\n/**\n * Extracts the module path(s) a Rust `use` declaration reaches into, dropping the imported leaf item(s).\n * Grouped imports are fully expanded so each imported item resolves to its own module, e.g.\n * `use std::{collections::HashMap, fmt};` yields `std::collections` and `std`, matching the single-item\n * forms `use std::collections::HashMap;` and `use std::fmt;`.\n */\nfunction findRustImportSources(node: Parser.SyntaxNode): string[] {\n  // `mod b;` (no body) pulls the child module's file into the tree, like an import of `self::b`.\n  if (node.type === 'mod_item') {\n    const nameNode = node.childForFieldName('name');\n    return nameNode ? [`self::${normalizeImportSource(nameNode.text)}`] : [];\n  }\n  // `extern crate serde as s;` names the crate directly; the alias is irrelevant to the source.\n  if (node.type === 'extern_crate_declaration') {\n    const nameNode = node.childForFieldName('name');\n    return nameNode ? [normalizeImportSource(nameNode.text)] : [];\n  }\n\n  const argument = node.childForFieldName('argument');\n  return argument ? rustImportSources(argument, '') : [];\n}\n\n/** Resolves the module source(s) of a `use` tree node, given the module `prefix` accumulated from ancestors. */\nfunction rustImportSources(node: Parser.SyntaxNode, prefix: string): string[] {\n  switch (node.type) {\n    case 'use_list': {\n      return node.namedChildren.flatMap((child) => rustImportSources(child, prefix));\n    }\n    case 'scoped_use_list': {\n      const listNode = node.childForFieldName('list');\n      const nextPrefix = joinModulePath(prefix, rustPathText(node.childForFieldName('path')));\n      return listNode ? rustImportSources(listNode, nextPrefix) : withModulePrefix(nextPrefix);\n    }\n    case 'scoped_identifier': {\n      // In-crate paths keep the leaf: `use crate::b;` names module `b`, and the resolver probes\n      // the parent module as a fallback when the leaf turns out to be an item, not a module.\n      const fullPath = joinModulePath(prefix, normalizeImportSource(node.text));\n      if (isRustLocalImportSource(fullPath)) {\n        return withModulePrefix(fullPath);\n      }\n      // Drop the leaf item: the source is the prefix plus this node's own `path` field.\n      return withModulePrefix(joinModulePath(prefix, rustPathText(node.childForFieldName('path'))));\n    }\n    case 'use_wildcard': {\n      // `use a::b::*;` imports from `a::b`; the wildcard has no `path` field, so its whole inner path counts.\n      return withModulePrefix(joinModulePath(prefix, rustPathText(node.namedChild(0))));\n    }\n    case 'use_as_clause': {\n      const pathNode = node.childForFieldName('path');\n      return pathNode ? rustImportSources(pathNode, prefix) : [];\n    }\n    case 'self': {\n      // `self` in a group (`use std::io::{self, Write};`) refers to the prefix module itself.\n      return withModulePrefix(prefix);\n    }\n    case 'identifier':\n    case 'crate':\n    case 'super': {\n      // Inside an in-crate group (`use crate::{a, b};`) each leaf may itself be a module; keep it\n      // and let the resolver fall back to the prefix module.\n      if (node.type === 'identifier' && isRustLocalImportSource(prefix)) {\n        return withModulePrefix(joinModulePath(prefix, normalizeImportSource(node.text)));\n      }\n      // A bare leaf item: at the top level (`use tokio;`) it is the module; inside a group its module is the prefix.\n      return withModulePrefix(prefix === '' ? normalizeImportSource(node.text) : prefix);\n    }\n    default: {\n      return [];\n    }\n  }\n}\n\nfunction rustPathText(node: Parser.SyntaxNode | null): string {\n  return node ? normalizeImportSource(node.text) : '';\n}\n\nfunction joinModulePath(prefix: string, segment: string): string {\n  if (!segment) {\n    return prefix;\n  }\n  return prefix ? `${prefix}::${segment}` : segment;\n}\n\nfunction withModulePrefix(source: string): string[] {\n  return source ? [source] : [];\n}\n\nfunction findPythonImportSources(node: Parser.SyntaxNode, options: { expandPythonSubmodules: boolean }): string[] {\n  if (node.type === 'import_from_statement') {\n    const moduleNode = node.childForFieldName('module_name');\n    if (!moduleNode) {\n      return [];\n    }\n\n    const moduleSource = normalizeImportSource(moduleNode.text);\n    const nameNodes = findChildrenByFieldName(node, 'name');\n    if (!options.expandPythonSubmodules || !moduleSource.startsWith('.')) {\n      return [moduleSource];\n    }\n    if (/^\\.+$/u.test(moduleSource) && nameNodes.length > 0) {\n      return nameNodes.flatMap(findPythonImportNames).map((name) => `${moduleSource}${name}`);\n    }\n    const submoduleSources = nameNodes.flatMap(findPythonImportNames).map((name) => `${moduleSource}.${name}`);\n    if (submoduleSources.length > 0) {\n      return [moduleSource, ...submoduleSources];\n    }\n    return [moduleSource];\n  }\n\n  if (node.type !== 'import_statement') {\n    return [];\n  }\n\n  return node.namedChildren\n    .map((child) => findPythonImportedModuleName(child))\n    .filter((source) => source !== undefined);\n}\n\nfunction findPythonImportNames(node: Parser.SyntaxNode): string[] {\n  if (node.type === 'aliased_import') {\n    const nameNode = node.childForFieldName('name');\n    return nameNode ? findPythonImportNames(nameNode) : [];\n  }\n\n  if (node.type === 'identifier') {\n    return [node.text];\n  }\n\n  if (node.type === 'dotted_name') {\n    return [normalizeImportSource(node.text)];\n  }\n\n  return node.namedChildren.flatMap(findPythonImportNames);\n}\n\nfunction findChildrenByFieldName(node: Parser.SyntaxNode, fieldName: string): Parser.SyntaxNode[] {\n  const children: Parser.SyntaxNode[] = [];\n  for (let index = 0; index < node.childCount; index += 1) {\n    const child = node.child(index);\n    if (child && node.fieldNameForChild(index) === fieldName) {\n      children.push(child);\n    }\n  }\n  return children;\n}\n\nfunction findPythonImportedModuleName(node: Parser.SyntaxNode): string | undefined {\n  if (node.type === 'dotted_name' || node.type === 'relative_import') {\n    return normalizeImportSource(node.text);\n  }\n\n  const nameNode = node.childForFieldName('name');\n  if (nameNode) {\n    return normalizeImportSource(nameNode.text);\n  }\n\n  for (const child of node.namedChildren) {\n    const source = findPythonImportedModuleName(child);\n    if (source) {\n      return source;\n    }\n  }\n\n  return undefined;\n}\n\nfunction normalizeImportSource(source: string): string {\n  return source.replaceAll(/\\s+/gu, '');\n}\n\nfunction findFirstStringNode(node: Parser.SyntaxNode): Parser.SyntaxNode | undefined {\n  if (isStringNode(node)) {\n    return node;\n  }\n\n  for (const child of node.namedChildren) {\n    const stringNode = findFirstStringNode(child);\n    if (stringNode) {\n      return stringNode;\n    }\n  }\n\n  return undefined;\n}\n\nfunction isStringNode(node: Parser.SyntaxNode): boolean {\n  return node.type === 'string' || node.type === 'string_literal' || node.type === 'interpreted_string_literal';\n}\n\nfunction unquote(value: string): string {\n  return value.replaceAll(/^['\"`<]|['\"`>]$/gu, '');\n}\n\nfunction isExportNode(node: Parser.SyntaxNode): boolean {\n  // Java's JPMS `exports com.example.api;` directive is module wiring, not a symbol export.\n  return (\n    (node.type.startsWith('export') && node.type !== 'exports_module_directive') ||\n    node.type === 'public_field_definition'\n  );\n}\n\nfunction findRecursiveIndexes(graph: Map<number, Set<number>>): Set<number> {\n  const recursiveIndexes = new Set<number>();\n\n  for (const index of graph.keys()) {\n    if (canReach(index, index, graph, new Set())) {\n      recursiveIndexes.add(index);\n    }\n  }\n\n  return recursiveIndexes;\n}\n\nfunction canReach(start: number, target: number, graph: Map<number, Set<number>>, visited: Set<number>): boolean {\n  const callees = graph.get(start);\n  if (!callees) {\n    return false;\n  }\n\n  for (const callee of callees) {\n    if (callee === target) {\n      return true;\n    }\n\n    if (!visited.has(callee)) {\n      visited.add(callee);\n      if (canReach(callee, target, graph, visited)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\nfunction measureMaxCallDepth(graph: Map<number, Set<number>>): number {\n  const depthByIndex = new Map<number, number>();\n  let maxDepth = 0;\n  for (const index of graph.keys()) {\n    maxDepth = Math.max(maxDepth, measureCallDepth(index, graph, new Set(), depthByIndex).depth);\n  }\n  return maxDepth;\n}\n\n/**\n * Longest-path DFS with memoization (O(V+E) on acyclic regions); a per-path copy of the on-stack\n * set made this exponential in path count. A depth computed under an on-stack cycle cut is valid\n * only for that path, so tainted results are NOT memoized — other entry points recompute them,\n * keeping values identical to the per-path algorithm while acyclic regions stay memoized.\n */\nfunction measureCallDepth(\n  index: number,\n  graph: Map<number, Set<number>>,\n  pathIndexes: Set<number>,\n  depthByIndex: Map<number, number>\n): { depth: number; tainted: boolean } {\n  const memoized = depthByIndex.get(index);\n  if (memoized !== undefined) {\n    return { depth: memoized, tainted: false };\n  }\n  const callees = graph.get(index);\n  if (!callees || callees.size === 0) {\n    return { depth: 0, tainted: false };\n  }\n  if (pathIndexes.has(index)) {\n    return { depth: 0, tainted: true };\n  }\n\n  pathIndexes.add(index);\n  let maxDepth = 0;\n  let tainted = false;\n  for (const callee of callees) {\n    const result = measureCallDepth(callee, graph, pathIndexes, depthByIndex);\n    maxDepth = Math.max(maxDepth, 1 + result.depth);\n    tainted ||= result.tainted;\n  }\n  pathIndexes.delete(index);\n  if (!tainted) {\n    depthByIndex.set(index, maxDepth);\n  }\n  return { depth: maxDepth, tainted };\n}\n\nfunction countIntersection(left: Set<string>, right: Set<string>): number {\n  const [smaller, larger] = left.size <= right.size ? [left, right] : [right, left];\n  let count = 0;\n  for (const value of smaller) {\n    if (larger.has(value)) {\n      count += 1;\n    }\n  }\n  return count;\n}\n\nfunction calculateMaintainabilityIndex(volume: number, complexity: number, loc: number): number {\n  if (loc === 0) {\n    return 100;\n  }\n\n  const raw = 171 - 5.2 * Math.log(Math.max(volume, 1)) - 0.23 * complexity - 16.2 * Math.log(loc);\n  return Math.max(0, Math.min(100, (raw * 100) / 171));\n}\n\nfunction incrementCount(map: Map<string, number>, value: string): void {\n  map.set(value, (map.get(value) ?? 0) + 1);\n}\n\nfunction maxMetric(functions: FunctionMetrics[], key: 'cyclomaticComplexity' | 'cognitiveComplexity'): number {\n  return functions.length === 0 ? 0 : Math.max(...functions.map((fn) => fn[key]));\n}\n\nfunction maxMapValue(map: Map<unknown, number>): number {\n  let maximum = 0;\n  for (const value of map.values()) {\n    maximum = Math.max(maximum, value);\n  }\n  return maximum;\n}\n\nfunction sum(values: Iterable<number>): number {\n  let total = 0;\n  for (const value of values) {\n    total += value;\n  }\n  return total;\n}\n"],"mappings":"yIAmBA,MAAM,EAAmB,IAAI,IAAI,CAAC,KAAM,KAAM,MAAO,IAAI,CAAC,EACpD,EAAgB,IAAI,IAAI,uZAsG9B,CAAC,EAEK,EAAmB,IAAI,IAAI,4qBAoDjC,CAAC,EAUK,EAAyB,IAAI,IAAI,CACrC,6BACA,QACA,uBACA,gBACA,sBACA,uBACA,4BACF,CAAC,EAwCD,IAAa,EAAb,KAA0B,CACxB,SAA4B,EAAuB,EAEnD,iBAAiB,EAAoC,CACnD,KAAK,SAAS,IAAI,EAAS,KAAM,CAAQ,EACzC,IAAK,IAAM,KAAS,EAAS,SAAW,CAAC,EACvC,KAAK,SAAS,IAAI,EAAO,CAAQ,CAErC,CAEA,uBAAwC,CACtC,MAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,OAAO,CAAC,CAAC,CAAC,IAAK,GAAa,EAAS,IAAI,CAAC,CAAC,CAClF,CAEA,QAAQ,EAAc,EAAsC,CAC1D,IAAM,EAAW,KAAK,SAAS,IAAI,EAAQ,QAAQ,EACnD,GAAI,CAAC,EACH,MAAU,MAAM,yBAAyB,EAAQ,UAAU,EAG7D,IAAM,EAAS,IAAI,EACnB,EAAO,YAAY,EAAS,cAAc,EAI1C,IAAM,EAHO,EAAO,MAAM,EAAM,IAAA,GAAW,CACzC,WAAY,EAAK,OAAS,CAC5B,CACgB,CAAC,CAAC,SAIZ,EAAoB,EAAyB,EAHjC,EAAa,EAAM,IAAI,IAAI,EAAS,iBAAiB,CAAC,CAAC,CAAC,OACvE,GAAS,CAAC,EAAkB,CAAI,GAAK,GAAsB,CAAI,CAED,EAAG,CAAQ,EACtE,EAAkB,EAAkB,UACpC,EAAmB,GAAkB,EAAM,EAAU,EAAG,EAAK,EAC7D,CAAE,QAAO,mBAAoB,GAAc,EAAM,CAAI,EACrD,EAAW,GAAgB,EAAM,CAAI,EAE3C,MAAO,CACL,SAAU,EAAS,KACnB,MAAO,OAAO,WAAW,CAAI,EAC7B,QACA,UAAW,EACX,WAAY,GAAa,EAAM,CAAQ,EACvC,cAAe,EAAgB,OAC/B,qBAAsB,EAAiB,qBACvC,wBAAyB,GAAU,EAAiB,sBAAsB,EAC1E,oBAAqB,EAAiB,oBACtC,uBAAwB,GAAU,EAAiB,qBAAqB,EACxE,aAAc,EAAiB,aAC/B,UAAW,EAAkB,UAC7B,SAAU,EAAkB,SAC5B,OAAQ,EAAkB,OAC1B,SAAU,EAAkB,SAC5B,eAAgB,EAAkB,eAClC,eAAgB,EAAkB,eAClC,YAAa,EAAmB,EAAM,CAAe,EACrD,WACA,qBAAsB,GACpB,EAAS,OACT,EAAiB,qBACjB,EAAM,IACR,EACA,WAAY,EAAQ,kBAAoB,EAAK,SAAS,EAAI,IAAA,EAC5D,CACF,CACF,EAEA,MAAa,EAAkB,IAAI,EAEnC,SAAgB,EAAY,EAAc,EAAsC,CAC9E,OAAO,EAAgB,QAAQ,EAAM,CAAO,CAC9C,CAEA,SAAS,EACP,EACA,EACA,EACmB,CACnB,IAAM,EAAuB,GAA4B,EAAM,CAAQ,EACjE,EAAW,EAAU,KAAK,EAAM,IAAU,EAAgB,EAAM,EAAU,EAAO,CAAoB,CAAC,EACtG,EAAY,EAAiB,CAAQ,EAkB3C,MAAO,CACL,UAlByB,EAAS,IAAK,IAAc,CACrD,KAAM,EAAS,KACf,UAAW,EAAS,UACpB,YAAa,EAAS,YACtB,QAAS,EAAS,QAClB,WAAY,EAAS,WACrB,qBAAsB,EAAS,qBAC/B,oBAAqB,EAAS,oBAC9B,aAAc,EAAS,aACvB,UAAW,EAAS,UACpB,kBAAmB,EAAS,QAAQ,KACpC,MAAO,EAAU,aAAa,IAAI,EAAS,KAAK,GAAK,EACrD,OAAQ,EAAU,cAAc,IAAI,EAAS,KAAK,GAAK,EACvD,eAAgB,EAAS,eACzB,UAAW,EAAU,iBAAiB,IAAI,EAAS,KAAK,CAC1D,EAG8B,EAC5B,UAAW,EAAU,QACrB,SAAU,GAAgB,EAAM,CAAQ,EACxC,OAAQ,GAAc,EAAM,CAAQ,EACpC,SAAU,GAAgB,CAAQ,EAClC,eAAgB,GAAsB,EAAM,EAAS,IAAI,EACzD,eAAgB,GAAsB,CAAI,CAC5C,CACF,CAEA,SAAS,EACP,EACA,EACA,EACA,EACkB,CAClB,IAAM,EAAa,GAAkB,EAAM,EAAU,EAAG,EAAI,EACtD,EAAQ,GAAa,EAAM,EAAU,CAAoB,EAC/D,MAAO,CACL,QACA,KAAM,GAAiB,CAAI,EAC3B,UAAW,EAAK,cAAc,IAAM,EACpC,YAAa,EAAK,cAAc,OAChC,QAAS,EAAK,YAAY,IAAM,EAChC,WAAY,GAAW,EAAM,CAAQ,EACrC,qBAAsB,EAAW,qBACjC,oBAAqB,EAAW,oBAChC,aAAc,EAAW,aACzB,UAAW,EAAM,UACjB,eAAgB,EAAgB,CAAI,EACpC,QAAS,EAAM,QACf,YAAa,GAAmB,CAAI,CACtC,CACF,CAGA,SAAS,EAAgB,EAAiC,CAExD,GAAI,EAAK,kBAAkB,WAAW,EACpC,MAAO,GAGT,IAAM,EAAiB,EAAmB,CAAI,EAC9C,GAAI,CAAC,EACH,MAAO,GAIT,GAAI,EAAe,OAAS,aAC1B,MAAO,GAIT,IAAM,EAAgB,IAAI,IAAI,EAAwB,EAAgB,QAAQ,CAAC,CAAC,IAAK,GAAU,EAAM,EAAE,CAAC,EA0BxG,OAvBmB,EACjB,EAAe,cACZ,OACE,GACC,EAAM,OAAS,WACf,EAAM,OAAS,kBACf,EAAM,OAAS,sBAEf,EAAM,OAAS,wBACf,EAAM,OAAS,qBACf,CAAC,EAAc,IAAI,EAAM,EAAE,GAC3B,CAAC,EAAgB,CAAK,CAC1B,CAAC,CAEA,IAAK,GACJ,EAAM,OAAS,wBAA0B,KAAK,IAAI,EAAG,EAAwB,EAAO,MAAM,CAAC,CAAC,MAAM,EAAI,CACxG,CAOY,EAHe,EAAe,SAAS,OACpD,GAAU,CAAC,EAAM,SAAW,EAAM,OAAS,KAC9C,CAAC,CAAC,MAEJ,CAGA,SAAS,EAAgB,EAAkC,CACzD,OACE,EAAK,OAAS,yBACd,EAAK,kBAAkB,YAAY,IAAM,MACzC,EAAK,kBAAkB,MAAM,CAAC,EAAE,OAAS,MAE7C,CAEA,SAAS,EAAmB,EAAwD,CAClF,IAAM,EAAS,EAAK,kBAAkB,YAAY,EAClD,GAAI,EACF,OAAO,EAKT,GAAI,EAAK,OAAS,kCAChB,OAAO,EAAK,QAAQ,QAAQ,kBAAkB,YAAY,GAAK,IAAA,GAKjE,IAAI,EAAmD,EAAK,kBAAkB,YAAY,EAC1F,KAAO,GAAY,CACjB,IAAM,EAAa,EAAW,kBAAkB,YAAY,EAC5D,GAAI,EACF,OAAO,EAET,EAAa,EAAe,CAAU,CACxC,CAEA,OAAO,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,qBAAuB,EAAM,OAAS,gBAAgB,CACjH,CAEA,SAAS,EAAiB,EAKxB,CACA,IAAM,EAAgB,EAA+B,CAAQ,EACvD,EAAgB,IAAI,IAAI,EAAc,KAAK,CAAC,EAC5C,EAAe,IAAI,IACnB,EAAgB,IAAI,IACpB,EAAQ,IAAI,IACd,EAAY,EACZ,EAAoB,EAClB,EAAa,IAAI,IAEvB,IAAK,IAAM,KAAY,EAAU,CAC/B,GAAa,EAAS,UACtB,IAAK,IAAM,KAAU,EAAS,QAC5B,EAAW,IAAI,CAAM,EAGvB,IAAM,EAAsB,IAAI,IAAI,CAAC,GAAG,EAAS,OAAO,CAAC,CAAC,OAAQ,GAAW,EAAc,IAAI,CAAM,CAAC,CAAC,EACjG,EAAwB,IAAI,IAClC,IAAK,IAAM,KAAU,EAAqB,CACxC,IAAM,EAAc,EAAc,IAAI,CAAM,EACxC,IAAgB,IAAA,IAClB,EAAsB,IAAI,CAAW,CAEzC,CAEA,EAAM,IAAI,EAAS,MAAO,CAAqB,EAC/C,EAAc,IAAI,EAAS,MAAO,EAAoB,IAAI,EAC1D,GAAqB,EAAoB,KACzC,IAAK,IAAM,KAAe,EACxB,EAAa,IAAI,GAAc,EAAa,IAAI,CAAW,GAAK,GAAK,CAAC,CAE1E,CAEA,IAAM,EAAmB,GAAqB,CAAK,EAEnD,MAAO,CACL,eACA,gBACA,mBACA,QAAS,CACP,YACA,kBAAmB,EAAW,KAC9B,oBACA,kBAAmB,EAAI,CAAC,GAAG,EAAM,OAAO,CAAC,CAAC,CAAC,IAAK,GAAY,EAAQ,IAAI,CAAC,EACzE,uBAAwB,EAAiB,KACzC,SAAU,EAAY,CAAY,EAClC,UAAW,EAAY,CAAa,EACpC,aAAc,GAAoB,CAAK,CACzC,CACF,CACF,CAEA,SAAS,EAA+B,EAAmD,CACzF,IAAM,EAAgB,IAAI,IAC1B,IAAK,IAAM,KAAY,EAChB,EAAS,MAId,EAAc,IAAI,EAAS,KAAM,EAAc,IAAI,EAAS,IAAI,EAAI,IAAA,GAAY,EAAS,KAAK,EAEhG,OAAO,IAAI,IAAI,CAAC,GAAG,EAAc,QAAQ,CAAC,CAAC,CAAC,OAAQ,GAAqC,EAAM,KAAO,IAAA,EAAS,CAAC,CAClH,CAOA,MAAM,GAA4B,IAAI,IAAI,CACxC,sBACA,qBACA,0BACA,kCAEA,yBACF,CAAC,EAED,SAAS,GAAsB,EAAkC,CAO/D,MANI,CAAC,GAA0B,IAAI,EAAK,IAAI,GAAK,EAAK,kBAAkB,MAAM,IAAM,KAC3E,GAKF,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,eAAe,CAC1E,CAOA,SAAS,EAAkB,EAAkC,CAC3D,OAAQ,EAAK,OAAS,SAAW,EAAK,OAAS,aAAe,EAAK,QAAQ,OAAS,QACtF,CAEA,SAAS,EAAmB,EAAyB,EAAyC,CAC5F,OAAO,EAAkB,IAAI,EAAK,IAAI,GAAK,CAAC,EAAkB,CAAI,CACpE,CAEA,SAAS,GACP,EACA,EACA,EACA,EACkB,CAClB,IAAI,EAAuB,EACvB,EAAsB,EACtB,EAAe,EACb,EAAgB,IAAI,IAAI,EAAS,iBAAiB,EAClD,EAAgB,IAAI,IAAI,EAAS,iBAAiB,EAClD,EAAe,IAAI,IAAI,EAAS,gBAAgB,EAEtD,SAAS,EAAM,EAA4B,EAAwB,EAA2B,CAC5F,GAAI,GAAyB,CAAC,GAAc,EAAmB,EAAS,CAAa,EACnF,OAKF,IAAM,EAAa,EAAQ,SAAW,EAAc,IAAI,EAAQ,IAAI,GAAK,CAAC,GAAsB,CAAO,EACjG,EAAY,EAAQ,SAAW,EAAa,IAAI,EAAQ,IAAI,GAAK,CAAC,GAAsB,CAAO,EAI/F,EAAiB,GAAc,GAAwB,CAAO,EAEhE,IACF,GAAwB,EACxB,GAAuB,EAAiB,EAAI,EAAI,GAG9C,GAAkB,CAAO,IAC3B,GAAwB,EACxB,GAAuB,GAKrB,GAAe,CAAO,IACxB,GAAwB,EACxB,GAAuB,GAGzB,IAAM,EAAe,GAAa,CAAC,EAAiB,EAAiB,EAAI,EACzE,EAAe,KAAK,IAAI,EAAc,CAAY,EAElD,IAAK,IAAM,KAAS,EAAQ,SAC1B,EAAM,EAAO,EAAc,EAAK,CAEpC,CAEA,IAAK,IAAM,KAAS,EAAK,SACvB,EAAM,EAAO,EAAS,EAAK,EAG7B,MAAO,CAAE,uBAAsB,sBAAqB,cAAa,CACnE,CAGA,SAAS,GAAe,EAAkC,CAOxD,OANK,EAAK,QAGN,EAAK,OAAS,SAAW,EAAK,OAAS,YAAc,EAAK,OAAS,gBAAkB,EAAK,OAAS,YAC9F,GAEF,EAAK,OAAS,iBAAmB,EAAK,SAAS,KAAM,GAAU,CAAC,EAAM,SAAW,EAAM,OAAS,IAAI,EALlG,EAMX,CAGA,SAAS,GAAwB,EAAkC,CACjE,GAAI,EAAK,OAAS,SAAW,EAAK,OAAS,cACzC,MAAO,GAET,GAAI,EAAK,OAAS,gBAAkB,EAAK,OAAS,iBAAmB,EAAK,OAAS,KACjF,MAAO,GAET,IAAM,EAAS,EAAK,OAKpB,OAJK,EAIE,EAAO,OAAS,eAAiB,EAAO,kBAAkB,aAAa,CAAC,EAAE,KAAO,EAAK,GAHpF,EAIX,CAOA,SAAS,GAAsB,EAAkC,CAC/D,GAAI,EAAK,OAAS,iBAChB,OAAO,EAAK,kBAAkB,OAAO,IAAM,KAG7C,GAAI,EAAK,OAAS,gCAAkC,EAAK,OAAS,cAAe,CAC/E,IAAM,EAAQ,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,cAAc,EAC9E,OAAO,IAAU,IAAA,IAAa,EAAM,kBAAoB,CAC1D,CAMA,GAAI,EAAK,OAAS,eAAiB,EAAK,OAAS,YAAa,CAC5D,IAAM,EAAU,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,gBAAkB,EAAM,OAAS,eAAe,EAClH,GAAI,CAAC,EACH,MAAO,GAET,GAAI,EAAQ,MAAM,CAAC,CAAC,EAAE,OAAS,MAAQ,EAAQ,aAAe,GAAK,EAAQ,MAAM,CAAC,CAAC,EAAE,OAAS,MAC5F,MAAO,GAET,IAAM,EAAY,EAAQ,kBAAoB,EAAI,EAAQ,WAAW,CAAC,EAAI,IAAA,GAC1E,OACE,EAAK,OAAS,eACd,GAAW,OAAS,eACpB,EAAU,kBAAoB,GAC9B,EAAU,WAAW,CAAC,CAAC,EAAE,OAAS,YAEtC,CAQA,OAJI,EAAK,OAAS,YACT,EAAK,WAAW,CAAC,CAAC,EAAE,OAAS,aAG/B,EACT,CAGA,MAAM,GAA6B,IAAI,IAAI,CAAC,oBAAqB,SAAU,kBAAkB,CAAC,EAO9F,SAAS,GAAkB,EAAkC,CAC3D,GAAI,EAAK,SAAW,CAAC,EAAiB,IAAI,EAAK,IAAI,EACjD,MAAO,GAGT,IAAM,EAAS,EAAK,OACpB,OAAO,IAAW,MAAQ,GAA2B,IAAI,EAAO,IAAI,CACtE,CAEA,SAAS,GACP,EACA,EACA,EAAoC,IAAI,IACK,CAC7C,IAAM,EAAU,IAAI,IACd,EAAoB,IAAI,IAAI,EAAS,iBAAiB,EACxD,EAAY,EAEhB,SAAS,EAAM,EAAyB,EAA2B,CAC7D,MAAC,GAAc,EAAmB,EAAM,CAAiB,GAK7D,IAAI,IAAS,OAAS,OAAS,GAAoB,CAAI,GAEhD,GAAI,EAAW,CAAI,EAAG,CAC3B,GAAa,EASb,IAAM,EAJJ,EAAS,OAAS,QACjB,EAAK,OAAS,kBACZ,EAAK,OAAS,mBACb,EAAqB,IAAI,EAAgB,EAAK,kBAAkB,UAAU,CAAC,GAAK,EAAE,GAClD,IAAA,GAAY,GAAe,CAAI,EAMrE,GALI,GACF,EAAQ,IAAI,CAAM,EAKlB,EAAS,OAAS,QAClB,EAAK,OAAS,QACd,EAAK,QAAQ,OAAS,uBACtB,EAAK,OAAO,kBAAkB,MAAM,CAAC,EAAE,KAAO,EAAK,GACnD,CACA,GAAa,EACb,IAAM,EAAe,EAAK,kBAAkB,QAAQ,EAChD,GACF,EAAQ,IAAI,GAAG,EAAa,KAAK,EAAE,CAEvC,CACF,MAAW,GAAmB,EAAM,CAAQ,GAAK,GAAkB,EAAM,CAAoB,KAG3F,GAAa,GAGf,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,EAAO,EAAK,CAJL,CAMjB,CAGA,OADA,EAAM,EAAM,EAAI,EACT,CAAE,YAAW,SAAQ,CAC9B,CAEA,MAAM,GAAgB,IAAI,IAAI,CAAC,cAAe,eAAgB,aAAc,kBAAkB,CAAC,EAG/F,SAAS,GAAoB,EAAkC,CAC7D,GAAI,EAAK,OAAS,kBAChB,MAAO,GAET,IAAM,EAAS,EAAK,kBAAkB,UAAU,EAChD,GAAI,GAAQ,OAAS,iBACnB,MAAO,GAET,IAAM,EAAO,GAAQ,OAAS,oBAAsB,EAAO,kBAAkB,MAAM,CAAC,EAAE,KAAO,GAAQ,KACrG,OAAO,IAAS,IAAA,IAAa,GAAc,IAAI,CAAI,CACrD,CAOA,SAAS,GAAkB,EAAyB,EAA4C,CAC9F,GAAI,EAAqB,OAAS,EAChC,MAAO,GAET,GAAI,EAAK,OAAS,8BAChB,OAAO,EAAqB,IAAI,EAAgB,EAAK,kBAAkB,MAAM,CAAC,GAAK,EAAE,EAEvF,GAAI,EAAK,OAAS,kBAAmB,CACnC,IAAM,EAAQ,EAAK,kBAAkB,OAAO,EAI5C,OAHI,GAAO,OAAS,iBAAmB,GAAO,OAAS,mBAC9C,GAEF,EAAqB,IAAI,EAAgB,EAAK,QAAQ,kBAAkB,MAAM,CAAC,GAAK,EAAE,CAC/F,CAIA,IACG,EAAK,OAAS,cAAgB,EAAK,OAAS,qBAC7C,EAAK,QAAQ,OAAS,eACtB,EAAwB,EAAK,OAAQ,YAAY,CAAC,CAAC,KAAM,GAAe,EAAW,KAAO,EAAK,EAAE,GACjG,CAAC,EAAgB,EAAK,OAAQ,QAAQ,EACtC,CACA,IAAI,EAAgD,EACpD,KAAO,GAAS,OAAS,oBACvB,EAAU,EAAQ,kBAAkB,YAAY,EAElD,OACE,GAAS,OAAS,cAClB,EAAqB,IAAI,EAAgB,EAAK,OAAO,kBAAkB,MAAM,CAAC,GAAK,EAAE,CAEzF,CAIA,GAAI,EAAK,OAAS,oBAAqB,CACrC,IAAM,EAAW,EAAK,WAAW,CAAC,EAC5B,EAAO,GAAU,OAAS,mBAAqB,EAAS,KAAO,EAAgB,CAAQ,EAC7F,OAAO,EAAqB,IAAI,GAAQ,EAAE,CAC5C,CACA,MAAO,EACT,CAOA,SAAS,EAAgB,EAAgE,CACvF,IAAI,EAAgD,EACpD,KAAO,GAAS,CACd,GAAI,EAAQ,OAAS,mBAAqB,EAAQ,OAAS,aACzD,OAAO,EAAQ,KAEjB,GACE,EAAQ,OAAS,wBACjB,EAAQ,OAAS,qBACjB,EAAQ,OAAS,iBACjB,EAAQ,OAAS,oBACjB,CACA,EAAU,EAAQ,kBAAkB,MAAM,EAC1C,QACF,CACA,MACF,CAEF,CAEA,MAAM,GAAyB,IAAI,IAAI,CAAC,kBAAmB,mBAAoB,iBAAiB,CAAC,EAGjG,SAAS,GAA4B,EAAyB,EAA2C,CACvG,IAAM,EAAQ,IAAI,IAClB,GAAI,EAAS,OAAS,MACpB,OAAO,EAET,IAAK,IAAM,KAAQ,EAAa,EAAM,EAAsB,EAAG,CAC7D,IAAM,EAAO,EAAK,kBAAkB,MAAM,CAAC,EAAE,KACzC,GAAQ,EAAK,kBAAkB,MAAM,GACvC,EAAM,IAAI,CAAI,CAElB,CACA,OAAO,CACT,CAUA,SAAS,GAAmB,EAAyB,EAAuC,CAI1F,OAHI,EAAS,OAAS,OAGf,EAAK,OAAS,SAAY,EAAK,OAAS,SAAW,EAAK,QAAQ,OAAS,OAFvE,EAGX,CAEA,SAAS,GAAmB,EAAsC,CAChE,IAAM,EAAc,IAAI,IAExB,SAAS,EAAM,EAA+B,EAE1C,EAAK,OAAS,cACd,EAAK,OAAS,uBACd,EAAK,OAAS,oBACd,EAAK,OAAS,YACd,EAAK,OAAS,qBACd,EAAK,OAAS,kBACd,EAAK,OAAS,oBAEd,EAAY,IAAI,EAAK,IAAI,EAG3B,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,CAAK,CAEf,CAGA,OADA,EAAM,CAAI,EACH,CACT,CAGA,SAAS,GAAa,EAAyB,EAAsC,CACnF,OAAO,EAAa,EAAM,IAAI,IAAI,EAAS,cAAc,CAAC,CAAC,CAAC,OAAO,EAAoB,CAAC,CAAC,MAC3F,CAMA,SAAS,GAAqB,EAAkC,CAI9D,OAHI,EAAK,OAAS,8BAAgC,EAAK,OAAS,gBACvD,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,YAAY,EAEhE,CAAC,EAAK,KAAK,SAAS,YAAY,GAAK,EAAK,kBAAkB,MAAM,IAAM,IACjF,CAEA,SAAS,EAAa,EAAyB,EAA6C,CAC1F,IAAM,EAA6B,CAAC,EAEpC,SAAS,EAAM,EAA+B,CACxC,EAAU,IAAI,EAAK,IAAI,GACzB,EAAM,KAAK,CAAI,EAGjB,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,CAAK,CAEf,CAGA,OADA,EAAM,CAAI,EACH,CACT,CAEA,SAAS,GAAW,EAAyB,EAAuC,CAClF,IAAM,EAAoB,IAAI,IAAI,EAAS,iBAAiB,EAE5D,SAAS,EAAM,EAAyB,EAA8B,CACpE,GAAI,CAAC,GAAc,EAAkB,IAAI,EAAK,IAAI,EAChD,MAAO,GAOT,GAJI,EAAK,OAAS,oBAKhB,EAAK,OAAS,kBACd,IAAS,GAAqB,CAAI,GAClC,EAAK,OAAS,mBACd,CAAC,EAAkB,IAAI,EAAK,IAAI,EAEhC,OAAO,EAAsB,EAAM,CAAiB,GAAK,EAA+B,EAAM,CAAiB,EAGjH,IAAK,IAAM,KAAS,EAAK,cACvB,GAAI,EAAM,EAAO,EAAK,EACpB,MAAO,GAGX,MAAO,EACT,CAEA,OAAO,EAAM,EAAM,EAAI,CACzB,CAEA,SAAS,GAAqB,EAAwD,CACpF,OAAO,EAAK,kBAAkB,MAAM,GAAK,EAAK,WAAW,EAAK,gBAAkB,CAAC,GAAK,IAAA,EACxF,CAEA,SAAS,EAAsB,EAAyB,EAAyC,CAC/F,OAAO,GACL,EACA,EACC,GAAS,EAAK,KAAK,WAAW,MAAM,GAAK,GAAiB,EAAM,CAAiB,CACpF,CACF,CAEA,SAAS,EAA+B,EAAyB,EAAyC,CACxG,OAAO,GAAa,EAAM,EAAmB,EAAwB,CACvE,CAEA,SAAS,GACP,EACA,EACA,EACS,CACT,SAAS,EAAM,EAAyB,EAA8B,CACpE,GAAI,CAAC,GAAc,EAAkB,IAAI,EAAK,IAAI,EAChD,MAAO,GAGT,GAAI,EAAU,CAAI,EAChB,MAAO,GAGT,IAAK,IAAM,KAAS,EAAK,cACvB,GAAI,EAAM,EAAO,EAAK,EACpB,MAAO,GAGX,MAAO,EACT,CAEA,OAAO,EAAM,EAAM,EAAI,CACzB,CAEA,SAAS,GAAiB,EAAyB,EAAyC,CAK1F,MAJI,CAAC,EAAW,CAAI,GAAK,CAAC,GAAqB,EAAK,kBAAkB,UAAU,GAAK,EAAK,WAAW,CAAC,CAAC,EAC9F,GAGF,EAAK,cAAc,KAAM,GAAU,GAA4B,EAAO,CAAiB,CAAC,CACjG,CAEA,SAAS,GAAqB,EAAyC,CACrE,GAAI,CAAC,EACH,MAAO,GAGT,IAAM,EAAa,EAAwB,CAAI,EAC/C,OAAO,IAAe,OAAS,IAAe,SAChD,CAEA,SAAS,GAA4B,EAAyB,EAAyC,CAKrG,OAJI,EAAkB,IAAI,EAAK,IAAI,EAC1B,GAA2B,EAAM,CAAiB,EAGpD,EAAK,cAAc,KAAM,GAAU,GAA4B,EAAO,CAAiB,CAAC,CACjG,CAEA,SAAS,GAA2B,EAAyB,EAAyC,CACpG,IAAM,EAAO,EAAK,OAAS,iBAAmB,GAAqB,CAAI,EAAI,IAAA,GAK3E,OAJI,GAAQ,EAAK,OAAS,mBAAqB,CAAC,EAAkB,IAAI,EAAK,IAAI,EACtE,EAAsB,EAAM,CAAiB,GAAK,EAA+B,EAAM,CAAiB,EAG1G,GACL,EACA,EACC,GAAS,EAAsB,EAAM,CAAiB,GAAK,EAA+B,EAAM,CAAiB,CACpH,CACF,CAEA,SAAS,GACP,EACA,EACA,EACS,CACT,SAAS,EAAM,EAAyB,EAA8B,CACpE,GAAI,CAAC,GAAc,EAAkB,IAAI,EAAK,IAAI,EAChD,MAAO,GAGT,GAAI,EAAK,OAAS,oBAAsB,EAAU,CAAI,EACpD,MAAO,GAGT,IAAK,IAAM,KAAS,EAAK,cACvB,GAAI,EAAM,EAAO,EAAK,EACpB,MAAO,GAGX,MAAO,EACT,CAEA,OAAO,EAAM,EAAM,EAAI,CACzB,CAEA,SAAS,GAAc,EAAyB,EAA6C,CAC3F,IAAM,EAAgB,IAAI,IAE1B,SAAS,EAAa,EAA+B,CACnD,GAAI,GAAmB,EAAM,CAAQ,EACnC,IAAK,IAAM,KAAU,GAAkB,EAAM,EAAU,CAAE,uBAAwB,EAAK,CAAC,EACrF,EAAc,IAAI,CAAM,EAI5B,IAAK,IAAM,KAAS,EAAK,cACvB,EAAa,CAAK,CAEtB,CAIA,OAFA,EAAa,CAAI,EAEV,CACL,aAAc,GAA0B,EAAM,CAAQ,EACtD,cAAe,CAAC,GAAG,CAAa,CAClC,CACF,CAEA,SAAS,GAA0B,EAAyB,EAAoD,CAC9G,IAAM,EAAgB,GAAqB,CAAI,EACzC,EAAQ,EAAS,OAAS,OAAS,GAAqB,CAAI,EAAI,GACtE,OAAO,EAAK,cACT,QAAS,GAAU,EAA4B,EAAO,GAAO,EAAO,EAAS,OAAS,KAAK,CAAC,CAAC,CAC7F,IAAK,GAAiB,EAAc,IAAI,EAAY,IAAI,EAAI,CAAE,GAAG,EAAa,SAAU,EAAK,EAAI,CAAY,CAClH,CAGA,SAAS,GAAqB,EAAiC,CAE7D,IAAM,EADc,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,qBAC3C,CAAC,EAAE,cAAc,KACzC,GAAU,EAAM,OAAS,qBAAuB,EAAM,OAAS,YAClE,EACA,OAAO,EAAW,GAAG,EAAS,KAAK,IAAM,EAC3C,CAEA,MAAM,EAAoB,IAAI,IAAI,CAAC,SAAU,QAAS,iBAAiB,CAAC,EAExE,SAAS,EACP,EACA,EACA,EAAQ,GACR,EAAQ,GACc,CACtB,GAAI,EAAmB,CAAI,EACzB,OAAO,EAAK,cAAc,QAAS,GAAU,EAA4B,EAAO,GAAM,EAAO,CAAK,CAAC,EAMrG,GAAI,EAAK,OAAS,uBAAwB,CACxC,IAAM,EAAO,EAAK,kBAAkB,MAAM,CAAC,EAAE,KAK7C,OAJK,GAGY,EAAK,kBAAkB,MACzB,CAAC,EAAE,eAAiB,CAAC,EAAA,CAAG,QAAS,GAC9C,EAA4B,EAAO,EAAU,GAAG,IAAQ,EAAK,IAAK,CAAK,CACzE,EALS,CAAC,CAMZ,CA4BA,OA1BI,GAAuB,CAAI,EACtB,EAAK,cAAc,QAAS,GAAU,EAA4B,EAAO,EAAU,EAAO,CAAK,CAAC,EAIrG,EAAK,OAAS,cACT,EAAoB,GAA6B,EAAM,EAAU,CAAK,EAAG,CAAK,EAInF,EAAK,OAAS,kBACT,EAAoB,GAA+B,EAAM,CAAQ,EAAG,CAAK,EAI9E,EAAkB,IAAI,EAAK,IAAI,EAC1B,GAAyB,EAAM,EAAU,CAAK,EAMnD,EAAK,OAAS,cAAgB,EAAK,OAAS,sBACvC,EAAoB,GAAyB,EAAM,CAAQ,EAAG,EAAO,EAAI,EAG3E,EAAoB,EAAoB,EAAM,CAAQ,EAAG,CAAK,CACvE,CAOA,SAAS,EACP,EACA,EACA,EAAgB,GACM,CAItB,OAHK,EAGE,EAAa,IAAK,GACvB,GAAiB,EAAY,KAAK,SAAS,IAAI,EAC3C,EACA,CAAE,GAAG,EAAa,KAAM,GAAG,IAAQ,EAAY,MAAO,CAC5D,EANS,CAOX,CAOA,SAAS,GAAyB,EAAyB,EAAmB,EAAQ,GAA0B,CAC9G,IAAM,EAAe,EAAoB,EAAoB,EAAM,CAAQ,EAAG,EAAO,EAAI,EAGnF,EAAa,EAAa,GAAK,GAAG,EAAa,EAAE,CAAC,KAAK,IAAM,EAC7D,EAAW,EAAK,kBAAkB,MAAM,EAC9C,IAAK,IAAM,KAAS,GAAU,eAAiB,CAAC,EAC1C,EAAkB,IAAI,EAAM,IAAI,EAClC,EAAa,KAAK,GAAG,GAAyB,EAAO,EAAU,CAAU,CAAC,GACjE,EAAM,OAAS,cAAgB,EAAM,OAAS,wBACvD,EAAa,KAAK,GAAG,EAAoB,GAAyB,EAAO,CAAQ,EAAG,EAAY,EAAI,CAAC,EAGzG,OAAO,CACT,CAOA,SAAS,GAAyB,EAAyB,EAAyC,CAClG,GAAI,EAAK,OAAS,uBAAyB,CAAC,EAAK,SAAS,KAAM,GAAU,CAAC,EAAM,SAAW,EAAM,OAAS,KAAK,EAC9G,MAAO,CAAC,EAEV,IAAM,EAAO,EAAK,kBAAkB,MAAM,EAK1C,OAJK,GAGW,EAAK,OAAS,uBAAyB,EAAK,cAAgB,CAAC,CAAI,EAAA,CAE9E,OACE,GACC,EAAO,OAAS,YACf,EAAO,OAAS,oBAAsB,EAAO,kBAAkB,MAAM,CAAC,EAAE,OAAS,UACtF,CAAC,CACA,IAAK,IAAY,CAAE,WAAU,KAAM,EAAO,KAAM,UAAW,EAAO,cAAc,IAAM,CAAE,EAAE,EATpF,CAAC,CAUZ,CAEA,SAAS,GAA+B,EAAyB,EAAyC,CAExG,IAAM,EAAW,EAAK,kBAAkB,MAAM,EACxC,EAAe,EAAW,EAAoB,EAAU,CAAQ,EAAI,CAAC,EAGrE,EACJ,GAAU,KAAK,SAAS,YAAY,GAAK,CAAC,EAAS,kBAAkB,MAAM,EACvE,EAAS,kBAAkB,MAAM,CAAC,EAAE,KACpC,IAAA,GACA,EAAY,IAAI,IAAI,EAAa,IAAK,GAAgB,EAAY,IAAI,CAAC,EAC7E,IAAK,IAAM,KAAc,EAAwB,EAAM,YAAY,EAAG,CACpE,IAAM,EAAO,EAAW,OAAS,kBAAoB,EAAW,KAAO,EAAqB,CAAU,EAClG,GAAQ,IAAS,GAAmB,CAAC,EAAU,IAAI,CAAI,IACzD,EAAU,IAAI,CAAI,EAClB,EAAa,KAAK,CAAE,WAAU,OAAM,UAAW,EAAW,cAAc,IAAM,CAAE,CAAC,EAErF,CACA,OAAO,CACT,CAEA,MAAM,GAA2B,IAAI,IAAI,CACvC,kBACA,qBACA,mBACA,uBACA,aAEA,kBACF,CAAC,EAOD,SAAS,GAAsB,EAAkC,CAC/D,GAAI,EAAK,OAAS,sBAAwB,EAAK,OAAS,uBAAwB,CAC9E,IAAI,EAAgD,EACpD,KACE,IACC,EAAQ,OAAS,sBAChB,EAAQ,OAAS,wBACjB,EAAQ,OAAS,qBAEnB,EAAU,EAAe,CAAO,EAKlC,OAHI,GAAS,OAAS,sBACb,EAAQ,kBAAkB,YAAY,CAAC,EAAE,OAAS,2BAEpD,EACT,CAMA,OAJI,GAAyB,IAAI,EAAK,IAAI,EACjC,GAIP,EAAK,OAAS,uBAAyB,EAAK,kBAAkB,YAAY,CAAC,EAAE,OAAS,0BAE1F,CAGA,SAAS,EAAgB,EAAyB,EAA0B,CAC1E,OAAO,EAAK,SAAS,KAAM,GAAU,EAAM,OAAS,2BAA6B,EAAM,OAAS,CAAO,CACzG,CAQA,SAAS,GAAgC,EAAkC,CACzE,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAO9C,OALE,GAAU,OAAS,mBAClB,EAAS,OAAS,UAAY,EAAS,OAAS,UAAY,EAAS,OAAS,SAExE,GAEF,CAAC,GAAoB,EAAM,EAAS,IAAI,CACjD,CAGA,SAAS,GAAoB,EAAyB,EAAuB,CAC3E,IAAI,EAAO,EACX,KAAO,EAAK,QACV,EAAO,EAAK,OAEd,OAAO,EAAa,EAAM,IAAI,IAAI,CAAC,kBAAmB,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAAM,IAC9D,EAAW,kBAAkB,YAAY,GAAK,EAAW,kBAAkB,MAAM,EAAA,EACjF,OAAS,CAC7B,CACH,CAOA,SAAS,GAA6B,EAAyB,EAAmB,EAAQ,GAA6B,CACrH,GAAK,GAAS,GAAgC,CAAI,GAAM,EAAgB,EAAM,QAAQ,EACpF,MAAO,CAAC,EAIV,IAAM,EAAW,EAAK,kBAAkB,MAAM,EACxC,EAAe,EAAW,EAAoB,EAAU,CAAQ,EAAI,CAAC,EACrE,EAAY,IAAI,IAAI,EAAa,IAAK,GAAgB,EAAY,IAAI,CAAC,EACvE,EAAW,EAAgB,EAAM,QAAQ,EAC/C,IAAK,IAAM,KAAS,EAAK,cAAc,OAAO,EAAqB,EAAG,CAQpE,GALI,GAAY,EAAM,OAAS,mBAM7B,GACA,CAAC,GACD,CAAC,EAAgB,EAAM,QAAQ,GAC/B,CAAC,GAAiC,CAAK,GACvC,CAAC,EAAkB,EAAM,CAAK,EAE9B,SAEF,IAAM,EAAO,EAAqB,CAAK,EACnC,GAAQ,CAAC,EAAU,IAAI,CAAI,IAC7B,EAAU,IAAI,CAAI,EAClB,EAAa,KAAK,CAAE,WAAU,OAAM,UAAW,EAAM,cAAc,IAAM,CAAE,CAAC,EAEhF,CACA,OAAO,CACT,CAEA,SAAS,GAAiC,EAAwC,CAChF,IAAI,EACF,EAAW,OAAS,kBAAqB,EAAW,kBAAkB,YAAY,GAAK,EAAc,EACvG,KAAO,GAAS,CACd,GAAI,EAAQ,OAAS,uBACnB,MAAO,GAET,EAAU,EAAe,CAAO,CAClC,CACA,MAAO,EACT,CAEA,SAAS,EAAoB,EAAyB,EAAyC,CAQ7F,GALI,CAAC,GAA0B,CAAI,GAAM,EAAK,KAAK,SAAS,YAAY,GAAK,CAAC,EAAK,kBAAkB,MAAM,GAKvG,EAAgB,EAAM,QAAQ,EAChC,MAAO,CAAC,EAKV,GAAI,EAAK,OAAS,iBAChB,OAAO,GAA8B,EAAM,CAAQ,EAGrD,IAAM,EAAO,GAAoB,CAAI,EACrC,OAAO,EAAO,CAAC,CAAE,WAAU,OAAM,UAAW,EAAK,cAAc,IAAM,CAAE,CAAC,EAAI,CAAC,CAC/E,CAEA,SAAS,GAA8B,EAAyB,EAAyC,CACvG,IAAM,EAAqC,CAAC,EACtC,EAAU,EAAK,kBAAkB,MAAM,CAAC,EAAE,KAC5C,GACF,EAAa,KAAK,CAAE,WAAU,KAAM,EAAS,UAAW,EAAK,cAAc,IAAM,CAAE,CAAC,EAEtF,IAAM,EAAW,EAAK,SAAS,KAAM,GAAU,CAAC,EAAM,UAAY,EAAM,OAAS,SAAW,EAAM,OAAS,SAAS,EACpH,IAAK,IAAM,KAAc,EAAK,kBAAkB,MAAM,CAAC,EAAE,eAAiB,CAAC,EAAG,CAC5E,GAAI,EAAW,OAAS,aACtB,SAEF,IAAM,EAAO,EAAW,kBAAkB,MAAM,CAAC,EAAE,KAC/C,GACF,EAAa,KAAK,CAChB,WACA,KAAM,GAAY,EAAU,GAAG,EAAQ,IAAI,IAAS,EACpD,UAAW,EAAW,cAAc,IAAM,CAC5C,CAAC,CAEL,CACA,OAAO,CACT,CAEA,SAAS,GAAoB,EAA6C,CACxE,GAAI,EAAK,OAAS,sBAAwB,EAAK,kBAAkB,UAAU,EACzE,OAAO,GAA4B,CAAI,EAGzC,IAAI,EAAW,EAAK,kBAAkB,MAAM,EAuB5C,OAnBI,GAAU,OAAS,kBACrB,EAAW,EAAS,kBAAkB,MAAM,GAI1C,GAAU,OAAS,mBACd,EAAS,KAEd,EACK,EAAsB,CAAQ,EAAI,EAAS,KAAO,IAAA,GAKpC,EAAqB,EAAK,kBAAkB,YAAY,EAAG,EAC9E,GAIG,EAAK,cAAc,KAAK,CAAqB,CAAC,EAAE,IACzD,CAEA,SAAS,EAAmB,EAAkC,CAC5D,OAAO,EAAK,OAAS,oBAAsB,EAAK,OAAS,oBAC3D,CAEA,SAAS,GAAuB,EAAkC,CAChE,OACE,EAAK,OAAS,uBACd,EAAK,OAAS,wBACd,EAAK,OAAS,wBACd,EAAK,OAAS,oBACd,EAAK,OAAS,qBACd,EAAK,OAAS,mBACd,EAAK,OAAS,iBAId,EAAK,OAAS,yBACd,EAAK,OAAS,wBACd,EAAK,OAAS,oBACd,EAAK,OAAS,iBACd,EAAK,OAAS,cACd,EAAK,OAAS,gBACd,EAAK,OAAS,cAElB,CAEA,SAAS,GAA0B,EAAkC,CACnE,OACE,EAAK,OAAS,wBACd,EAAK,OAAS,uBACd,EAAK,OAAS,iBACd,EAAK,OAAS,sBACd,EAAK,OAAS,qBACd,EAAK,OAAS,oBACd,EAAK,OAAS,yBACd,EAAK,OAAS,0BACd,EAAK,OAAS,oBACd,EAAK,OAAS,aACd,EAAK,OAAS,cACd,EAAK,OAAS,YACd,EAAK,OAAS,uBACd,EAAK,OAAS,eACd,EAAK,OAAS,aACd,EAAK,OAAS,cACd,EAAK,OAAS,cACd,EAAK,OAAS,aACd,EAAK,OAAS,cACd,EAAK,OAAS,eACd,EAAK,OAAS,YAEd,EAAK,OAAS,oBACd,EAAK,OAAS,sBACd,EAAK,OAAS,+BAGd,EAAK,OAAS,UACd,EAAK,OAAS,oBACd,EAAK,OAAS,SACd,EAAK,OAAS,UAEd,EAAK,OAAS,qBACd,EAAK,OAAS,oBACd,EAAK,OAAS,mBACd,EAAK,OAAS,kBACd,EAAK,OAAS,iBAElB,CAEA,SAAS,EAAsB,EAAkC,CAC/D,OACE,EAAK,OAAS,cACd,EAAK,OAAS,mBACd,EAAK,OAAS,uBACd,EAAK,OAAS,oBAEd,EAAK,OAAS,UAElB,CAEA,SAAS,GAAqB,EAAsC,CAClE,IAAM,EAAgB,IAAI,IAE1B,SAAS,EAAM,EAAyB,EAAoC,CAC1E,GAAI,CAAC,GAAuB,GAAsB,CAAI,EAAG,CACvD,IAAM,EAAO,GAAiB,CAAI,EAC9B,GACF,EAAc,IAAI,CAAI,CAE1B,CAEA,IAAM,EACJ,GAAwB,EAAmB,CAAI,GAAK,EAAK,kBAAkB,QAAQ,IAAM,KAC3F,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,EAAO,CAAe,CAEhC,CAGA,OADA,EAAM,EAAM,EAAK,EACV,CACT,CAEA,SAAS,GAAsB,EAAkC,CAC/D,OAAO,EAAK,OAAS,oBAAsB,EAAK,OAAS,kBAC3D,CAEA,SAAS,GAAiB,EAA6C,CACrE,IAAM,EACJ,EAAK,kBAAkB,MAAM,GAAK,EAAK,kBAAkB,OAAO,GAAK,EAAK,cAAc,KAAK,CAAqB,EACpH,OAAO,GAAY,EAAsB,CAAQ,EAAI,EAAS,KAAO,IAAA,EACvE,CAEA,SAAS,GAA4B,EAA6C,CAChF,IAAM,EAAW,EAAK,kBAAkB,MAAM,EACxC,EAAmB,EAAK,kBAAkB,UAAU,CAAC,EAAE,cAAc,EAAE,EAAE,kBAAkB,MAAM,EAKvG,MAJI,CAAC,GAAY,CAAC,EAAsB,CAAQ,GAAK,CAAC,EAC7C,GAAY,EAAsB,CAAQ,EAAI,EAAS,KAAO,IAAA,GAGhE,GAAG,GAAwB,EAAiB,IAAI,EAAE,GAAG,EAAS,MACvE,CAEA,SAAS,GAAwB,EAA8B,CAC7D,OAAO,EAAa,WAAW,QAAS,EAAE,CAAC,CAAC,QAAQ,QAAS,EAAE,CACjE,CAEA,SAAS,GAAgB,EAAyB,EAA+C,CAC/F,IAAM,EAAgB,IAAI,IACtB,EAAc,EACd,EAAc,EAElB,SAAS,EAAM,EAA+B,CAgB5C,GAVE,EAFA,EAAS,OAAS,OAAS,EAAK,OAAS,sBAAwB,EAAK,OAAS,uBAG9E,GAAa,CAAI,GAChB,GAAqB,EAAM,CAAQ,GACnC,EAAkB,EAAM,CAAQ,GAChC,EAAoB,CAAI,GACxB,EAAkB,EAAM,CAAQ,KAElC,GAAe,GAGb,GAAmB,EAAM,CAAQ,EACnC,IAAK,IAAM,KAAU,GAAkB,EAAM,EAAU,CAAE,uBAAwB,EAAM,CAAC,EACtF,EAAc,IAAI,CAAM,EAIxB,GAAa,CAAI,IACnB,GAAe,GAGjB,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,CAAK,CAEf,CAEA,EAAM,CAAI,EAEV,IAAM,EAAsB,CAAC,GAAG,CAAa,CAAC,CAAC,OAAQ,GACrD,GAAuB,EAAQ,EAAS,IAAI,CAC9C,CAAC,CAAC,OAEF,MAAO,CACL,cACA,kBAAmB,EAAc,KACjC,sBACA,oBAAqB,EAAc,KAAO,EAC1C,aACF,CACF,CAEA,SAAS,GAAsB,EAAyB,EAA4C,CAClG,IAAM,EAAgC,CACpC,gBAAiB,EACjB,qBAAsB,EACtB,mBAAoB,EACpB,oBAAqB,EACrB,qBAAsB,EACtB,oBAAqB,EACrB,kBAAmB,CACrB,EAEA,SAAS,EAAM,EAA+B,CACxC,GAAiB,CAAI,IACvB,EAAQ,iBAAmB,GAEzB,GAAY,CAAI,IAClB,EAAQ,sBAAwB,GAE9B,GAAW,CAAI,IACjB,EAAQ,oBAAsB,GAEhC,EAAQ,qBAAuB,GAAqB,EAAM,CAAY,EAClE,GAAa,CAAI,IACnB,EAAQ,sBAAwB,GAE9B,GAAY,CAAI,IAClB,EAAQ,qBAAuB,GAE7B,GAAU,CAAI,IAChB,EAAQ,mBAAqB,GAG/B,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,CAAK,CAEf,CAGA,OADA,EAAM,CAAI,EACH,CACT,CAEA,SAAS,GAAiB,EAAkC,CAC1D,OACE,EAAK,OAAS,yBACd,EAAK,OAAS,mCACd,EAAK,OAAS,wBACd,EAAK,OAAS,cACd,EAAK,OAAS,wBACd,EAAK,OAAS,uBACd,EAAK,OAAS,yBACd,EAAK,OAAS,4BAEd,EAAK,OAAS,oBAEd,EAAK,OAAS,qBACd,EAAK,OAAS,iBACd,EAAK,OAAS,eAElB,CAEA,SAAS,GAAY,EAAkC,CACrD,OAAO,EAAK,OAAS,oBAAsB,EAAK,OAAS,SAAW,EAAK,OAAS,qBACpF,CAEA,SAAS,GAAW,EAAkC,CACpD,OACE,EAAK,OAAS,iBACd,EAAK,OAAS,oBACd,EAAK,OAAS,0BACd,EAAK,OAAS,kBACd,EAAK,OAAS,mBACd,EAAK,OAAS,gBACd,EAAK,OAAS,kBACd,EAAK,OAAS,oBACd,EAAK,OAAS,mBAEd,EAAK,OAAS,SACd,EAAK,OAAS,SACd,EAAK,OAAS,OACd,EAAK,OAAS,kBACd,EAAK,OAAS,gBAElB,CAOA,SAAS,GAAqB,EAAyB,EAA8B,CACnF,IAAM,EAAM,IAAiB,KAAO,IAAiB,MACrD,GAAI,EAAK,OAAS,8BAAiC,EAAK,OAAS,qBAAuB,IAAiB,OAAS,CAChH,IAAM,EAAkB,EAAK,cAAc,OAAQ,GAAU,EAAM,OAAS,qBAAqB,EACjG,OAAO,EAAyB,CAAI,EAAI,EAAgB,OAAS,CACnE,CAEA,GAAI,IAAQ,EAAK,OAAS,eAAiB,EAAK,OAAS,qBACvD,OAAO,EAAsB,EAAM,IAAiB,KAAK,EAM3D,GAAI,GAAO,EAAK,OAAS,sBAAuB,CAC9C,IAAM,EAAa,EAAK,kBAAkB,YAAY,EAItD,OAHI,GAAY,OAAS,oBAAsB,GAAY,OAAS,aAC3D,EAAsB,EAAM,IAAiB,KAAK,EAEpD,CACT,CAGA,GAAI,EAAK,OAAS,yBAChB,MAAO,KAAyB,CAAI,EAMtC,GACE,IAAiB,SAChB,EAAK,OAAS,yBAA2B,EAAK,OAAS,gBAAkB,EAAK,OAAS,4BACxF,CACA,IAAM,EACJ,EAAK,OAAS,wBACV,EAAK,kBAAkB,MAAM,IAAM,KACnC,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,YAAY,EAC9D,EAAU,EAAK,SAAS,KAAM,GAAU,CAAC,EAAM,SAAW,EAAM,OAAS,OAAO,EACtF,OAAO,GAAa,CAAC,EAAU,EAAI,CACrC,CAGA,GAAI,GAAO,EAAK,OAAS,iBAAkB,CACzC,IAAM,EAAa,EAAK,kBAAkB,YAAY,EACtD,OAAO,GAAc,EAAkB,EAAM,CAAU,EAAI,EAAuB,CAAU,EAAI,CAClG,CAEA,MAAO,MAAqB,CAAI,CAClC,CAEA,SAAS,EAAsB,EAAyB,EAAwB,CAK9E,OAHI,GAAS,GAAgC,CAAI,EACxC,EAEF,EACL,EAAK,cACF,OAAQ,GAAU,GAAsB,CAAK,GAAK,EAAkB,EAAM,CAAK,CAAC,CAAC,CACjF,IAAI,CAAsB,CAC/B,CACF,CAGA,SAAS,EAAuB,EAAuC,CACrE,IAAM,EACJ,EAAW,OAAS,kBAAqB,EAAW,kBAAkB,YAAY,GAAK,EAAc,EAIvG,OAHI,EAAM,OAAS,gCACV,KAAK,IAAI,EAAG,EAAM,cAAc,OAAQ,GAAU,EAAM,OAAS,YAAY,CAAC,CAAC,MAAM,EAEvF,CACT,CAEA,SAAS,GAAqB,EAAkC,CAC9D,OACG,EAAK,OAAS,uBAAyB,EAAK,YAAY,OAAS,OACjE,EAAK,OAAS,wBAA0B,EAAK,YAAY,OAAS,OACnE,EAAK,OAAS,mBACb,EAAK,OAAS,mBAAqB,GAAyB,CAAI,CAErE,CAGA,SAAS,EAAyB,EAAkC,CAElE,MAAO,CADW,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,WACpD,CAAC,EAAE,SAAS,KAAM,GAAU,EAAM,OAAS,OAAO,CACpE,CAQA,SAAS,EAAkB,EAAgC,EAAwC,CACjG,IAAI,EACF,EAAW,OAAS,kBAAqB,EAAW,kBAAkB,YAAY,GAAK,EAAc,EACnG,EAAgB,GACpB,KACE,EAAQ,OAAS,wBACjB,EAAQ,OAAS,sBACjB,EAAQ,OAAS,oBACjB,EAAQ,OAAS,4BACjB,EAAQ,OAAS,uBACjB,CAGA,GAAI,EAAQ,OAAS,uBACnB,MAAO,GAET,IAAM,EAAQ,EAAe,CAAO,EACpC,GAAI,CAAC,EACH,MAEF,GAAI,EAAQ,OAAS,uBACnB,EAAgB,GAGZ,EAAkB,CAAO,GAAK,CAAC,GAA+B,CAAK,GACrE,MAAO,GAGX,EAAU,CACZ,CAEA,OAAO,GAAiB,CAAC,EAAkB,CAAW,CACxD,CAEA,SAAS,GAA+B,EAAwC,CAC9E,IAAI,EAAgD,EACpD,KAAO,GAAS,CACd,GAAI,EAAQ,OAAS,qBACnB,MAAO,GAET,EAAU,EAAe,CAAO,CAClC,CACA,MAAO,EACT,CAEA,SAAS,EAAkB,EAAkC,CAC3D,OAAO,EAAK,cAAc,KACvB,GAAU,EAAM,OAAS,mBAAqB,EAAM,OAAS,SAAW,EAAM,OAAS,YAC1F,CACF,CASA,SAAS,GAAyB,EAAkC,CAClE,GAAI,EAAK,SAAS,KAAM,GAAU,EAAM,OAAS,mBAAmB,EAClE,MAAO,GAGT,IAAM,EAAU,EAAK,kBAAkB,SAAS,EAKhD,OAJK,EAIE,EACJ,kBAAkB,mBAAmB,CAAC,CACtC,KAAM,GAAc,EAAU,QAAQ,OAAS,mBAAmB,EAL5D,EAMX,CAEA,SAAS,GAAa,EAAkC,CAItD,OACE,EAAK,OAAS,oBACd,EAAK,OAAS,qBACd,EAAK,OAAS,UACd,EAAK,OAAS,qBAElB,CAEA,SAAS,GAAY,EAAkC,CACrD,OAAO,EAAK,OAAS,mBAAqB,EAAK,OAAS,mBAAqB,GAAgB,CAAI,CACnG,CAGA,SAAS,GAAgB,EAAkC,CACzD,GAAI,EAAK,OAAS,QAAU,EAAK,kBAAkB,UAAU,EAC3D,MAAO,GAGT,IAAM,EAAa,EAAK,kBAAkB,QAAQ,EAClD,OAAO,GAAY,OAAS,eAAiB,EAAW,OAAS,SAAW,EAAW,OAAS,OAClG,CAEA,SAAS,GAAU,EAAkC,CACnD,OACE,EAAK,OAAS,iBACd,EAAK,OAAS,gCAEd,EAAK,OAAS,mBACd,GAAsB,CAAI,CAE9B,CAOA,SAAS,GAAsB,EAAkC,CAE/D,OACG,EAAK,OAAS,SAAW,EAAK,OAAS,mBACxC,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,UAAY,EAAM,OAAS,QAAQ,CAEzF,CAKA,SAAS,GAAgB,EAA+C,CAGtE,IAAM,EAA4B,IAAI,IACtC,IAAK,IAAM,KAAY,EACrB,IAAK,IAAM,KAAc,EAAS,YAChC,EAA0B,IAAI,GAAa,EAA0B,IAAI,CAAU,GAAK,GAAK,CAAC,EAGlG,IAAI,EAAwB,EAC5B,IAAK,IAAM,KAAS,EAA0B,OAAO,EAC/C,GAAS,IACX,GAAyB,GAQ7B,IAAM,EAAgB,EAAS,OACzB,EAAkB,GAAiB,EAAgB,GAAM,EACzD,EAAS,KAAK,IAAI,EAAG,KAAK,KAAK,EAAiB,IAAoB,CAAC,EACvE,EAAe,EACf,EAAmB,EACnB,EAAY,EACZ,EAAoB,EACpB,EAAY,EAAgB,EAChC,IAAK,IAAI,EAAY,EAAG,EAAY,EAAgB,GAAa,EAAQ,CACvE,KAAO,GAAa,EAAoB,GACtC,GAAqB,EACrB,GAAa,EACb,EAAY,EAAgB,EAAI,EAElC,IAAM,EAAa,EAAY,GAAK,EAAY,GAE1C,EAAO,EAAS,GAChB,EAAQ,EAAS,GACvB,GAAI,CAAC,GAAQ,CAAC,EACZ,SAGF,IAAM,EAAmB,GAAkB,EAAK,YAAa,EAAM,WAAW,EACxE,EAAY,EAAK,YAAY,KAAO,EAAM,YAAY,KAAO,EACnE,GAAgB,IAAc,EAAI,EAAI,EAAmB,EACzD,GAAoB,CACtB,CAEA,MAAO,CACL,iCAAkC,IAAqB,EAAI,EAAI,EAAe,EAC9E,wBACA,sBAAuB,EAA0B,IACnD,CACF,CAEA,SAAS,GAAsB,EAAgD,CAC7E,IAAM,EAAiC,CACrC,oBAAqB,EACrB,eAAgB,EAChB,eAAgB,EAChB,sBAAuB,EACvB,eAAgB,EAChB,sBAAuB,EACvB,qBAAsB,EACtB,mBAAoB,EACpB,sBAAuB,EACvB,yBAA0B,CAC5B,EAEA,SAAS,EAAM,EAA+B,CAC5C,OAAQ,EAAK,KAAb,CACE,IAAK,kBACH,EAAQ,qBAAuB,EAC/B,MAEF,IAAK,yBACH,EAAQ,gBAAkB,EAC1B,MAEF,IAAK,wBACH,EAAQ,gBAAkB,EAC1B,MAEF,IAAK,kBACL,IAAK,iBACH,EAAQ,uBAAyB,IAAK,OAAS,kBAC/C,MAEF,IAAK,aACH,EAAQ,gBAAkB,EAC1B,MAEF,IAAK,oBACH,EAAQ,uBAAyB,EACjC,MAEF,IAAK,mBACH,EAAQ,sBAAwB,EAChC,MAEF,IAAK,gBACL,IAAK,iBACH,EAAQ,oBAAsB,EAC9B,MAEF,IAAK,sBACH,EAAQ,uBAAyB,EACjC,MAEF,IAAK,uBACH,EAAQ,0BAA4B,EACpC,KAEJ,CAEA,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,CAAK,CAEf,CAGA,OADA,EAAM,CAAI,EACH,CACT,CAMA,SAAS,GACP,EACA,EAC+D,CAC/D,IAAM,EAAc,EAAK,SAAW,EAAI,CAAC,EAAI,EAAK,MAAM,YAAY,EAG9D,EAAqB,IAAI,IAC/B,IAAK,IAAM,KAAQ,GAAoB,CAAI,EAAG,CAC5C,IAAM,EAAQ,EAAmB,IAAI,EAAK,IAAI,GAAK,CAAC,EACpD,EAAM,KAAK,CAAI,EACf,EAAmB,IAAI,EAAK,KAAM,CAAK,CACzC,CACA,IAAI,EAAQ,EACR,EAAU,EACR,EAAkB,IAAI,IAE5B,IAAK,GAAM,CAAC,EAAO,KAAS,EAAY,QAAQ,EAAG,CACjD,GAAI,EAAK,KAAK,IAAM,GAAI,CACtB,GAAS,EACT,QACF,CACI,GAAkB,EAAM,EAAmB,IAAI,CAAK,GAAK,CAAC,CAAC,EAC7D,GAAW,EAEX,EAAgB,IAAI,EAAQ,CAAC,CAEjC,CAEA,MAAO,CACL,MAAO,CACL,MAAO,EAAY,OACnB,KAAM,EAAgB,KACtB,UACA,OACF,EACA,iBACF,CACF,CAEA,SAAS,GAAoB,EAAwC,CACnE,IAAM,EAAuB,CAAC,EAE9B,SAAS,EAAM,EAA+B,CAC5C,GAAI,EAAK,OAAS,WAAa,EAAK,OAAS,gBAAkB,EAAK,OAAS,gBAC3E,IAAK,IAAI,EAAM,EAAK,cAAc,IAAK,GAAO,EAAK,YAAY,IAAK,GAAO,EACzE,EAAM,KAAK,CACT,KAAM,EACN,YAAa,IAAQ,EAAK,cAAc,IAAM,EAAK,cAAc,OAAS,EAC1E,UAAW,IAAQ,EAAK,YAAY,IAAM,EAAK,YAAY,OAAS,GACtE,CAAC,EAIL,IAAK,IAAM,KAAS,EAAK,cACvB,EAAM,CAAK,CAEf,CAGA,OADA,EAAM,CAAI,EACH,CACT,CAEA,SAAS,GAAkB,EAAc,EAAuC,CAC9E,GAAI,EAAc,SAAW,EAC3B,MAAO,GAKT,IAAK,IAAI,EAAS,EAAG,EAAS,EAAK,OAAQ,GAAU,EAC/C,UAAM,KAAK,EAAK,IAAW,GAAG,GAG9B,CAAC,EAAc,KAAM,GAAS,EAAK,aAAe,GAAU,EAAS,EAAK,SAAS,EACrF,MAAO,GAGX,MAAO,EACT,CAEA,SAAS,GAAgB,EAAyB,EAA+B,CAC/E,IAAM,EAAY,IAAI,IAChB,EAAW,IAAI,IAErB,SAAS,EAAM,EAA+B,CACxC,OAAK,OAAS,WAAa,EAAK,OAAS,gBAAkB,EAAK,OAAS,iBAI7E,IAAI,EAAuB,IAAI,EAAK,IAAI,EAAG,CACzC,EAAe,EAAU,EAAK,MAAM,EAAK,WAAY,EAAK,QAAQ,CAAC,EACnE,MACF,CAKA,GAAI,EAAK,aAAe,EAAG,CACzB,IAAM,EAAO,EAAK,MAAM,EAAK,WAAY,EAAK,QAAQ,EAIlD,EAAiB,IAAI,EAAK,IAAI,EAChC,EAAe,EAAU,CAAI,GACnB,EAAc,IAAI,CAAI,GAAK,EAAc,IAAI,EAAK,IAAI,IAAM,GAA2B,EAAM,CAAI,GAC3G,EAAe,EAAW,GAAQ,EAAK,IAAI,EAE7C,MACF,CAEA,IAAK,IAAM,KAAS,EAAK,SACvB,EAAM,CAAK,CAnBb,CAqBF,CAEA,EAAM,CAAI,EAEV,IAAM,EAAoB,EAAU,KAC9B,EAAmB,EAAS,KAC5B,EAAiB,EAAI,EAAU,OAAO,CAAC,EACvC,EAAgB,EAAI,EAAS,OAAO,CAAC,EACrC,EAAa,EAAoB,EACjC,EAAS,EAAiB,EAC1B,EAAS,IAAe,EAAI,EAAI,EAAS,KAAK,KAAK,CAAU,EAC7D,EAAa,IAAqB,EAAI,EAAK,EAAoB,GAAM,EAAgB,GACrF,EAAS,EAAa,EAE5B,MAAO,CACL,oBACA,mBACA,iBACA,gBACA,aACA,SACA,SACA,aACA,SACA,KAAM,EAAS,GACf,KAAM,EAAS,GACjB,CACF,CAEA,SAAS,GAAiB,EAA6C,CACrE,IAAM,EAAc,GAAyB,CAAI,EACjD,GAAI,EACF,OAAO,EAGT,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAC9C,GAAI,EACF,OAAO,EAAS,KAIlB,IAAM,EAAiB,GAAmB,CAAI,EAC9C,GAAI,EACF,OAAO,EAGT,IAAM,EAAS,EAAK,OACf,KAOL,IAAI,EAAK,OAAS,sBAAwB,EAAO,OAAS,kBAAmB,CAC3E,IAAM,EAAc,EAAO,kBAAkB,SAAS,EACtD,OAAO,GAAa,OAAS,aAAe,EAAY,KAAO,IAAA,EACjE,CAwBA,OApBI,EAAK,OAAS,qBAAuB,EAAO,OAAS,kBAChD,EAAqB,EAAO,kBAAkB,YAAY,CAAC,EAKhE,EAAK,OAAS,gBAAkB,EAAO,OAAS,kBAC3C,GAAsB,EAAM,CAAM,EAKvC,EAAK,OAAS,UAAY,EAAO,OAAS,aACrC,GAAuB,CAAM,GAEjC,EAAK,OAAS,SAAW,EAAK,OAAS,aAAe,GAAiB,CAAM,EACzE,EAAO,QAAQ,OAAS,aAAe,GAAuB,EAAO,MAAM,EAAI,IAAA,GAGrE,EAAO,kBAAkB,MAC5B,CAAC,EAAE,IAxBnB,CAyBF,CAEA,SAAS,GAAmB,EAA6C,CACvE,OAAO,EAAqB,EAAK,kBAAkB,YAAY,CAAC,CAClE,CAWA,SAAS,EAAqB,EAAsC,EAAY,GAA2B,CACzG,IAAI,EAAgD,EAChD,EAAc,GAClB,KAAO,GACL,OAAQ,EAAQ,KAAhB,CACE,IAAK,aACL,IAAK,mBACL,IAAK,kBACL,IAAK,kBACL,IAAK,gBACH,OAAO,EAAc,GAAG,EAAY,IAAI,EAAQ,OAAS,EAAQ,KAInE,IAAK,gBAAiB,CACpB,IAAM,EAAO,YAAY,EAAQ,kBAAkB,MAAM,CAAC,EAAE,MAAQ,KAAK,QAAQ,EACjF,OAAO,EAAc,GAAG,EAAY,IAAI,IAAS,CACnD,CAEA,IAAK,oBACH,EAAU,EAAQ,kBAAkB,MAAM,EAC1C,MAEF,IAAK,uBACH,GAAI,EAAW,CACb,IAAM,EAAQ,EAAQ,kBAAkB,OAAO,CAAC,EAAE,KAAK,WAAW,QAAS,EAAE,EACzE,IACF,EAAc,EAAc,GAAG,EAAY,IAAI,IAAU,EAE7D,CACA,EAAU,EAAQ,kBAAkB,MAAM,EAC1C,MAEF,QACE,EAAU,EAAe,CAAO,CAEpC,CAGJ,CAMA,SAAS,EAAe,EAAwD,CAC9E,IAAM,EAAS,EAAK,kBAAkB,YAAY,EAClD,GAAI,EACF,OAAO,EAET,GAAI,EAAK,OAAS,wBAA0B,EAAK,OAAS,2BACxD,OAAO,EAAK,WAAW,CAAC,GAAK,IAAA,EAGjC,CAEA,SAAS,GAAuB,EAAmD,CACjF,IAAM,EAAW,EAAW,kBAAkB,MAAM,EACpD,OAAO,GAAU,OAAS,cAAgB,GAAU,OAAS,WAAa,EAAS,KAAO,IAAA,EAC5F,CAEA,SAAS,GAAiB,EAAkC,CAC1D,GAAI,EAAK,OAAS,QAAU,EAAK,kBAAkB,UAAU,EAC3D,MAAO,GAET,IAAM,EAAa,EAAK,kBAAkB,QAAQ,EAClD,OAAO,GAAY,OAAS,eAAiB,EAAW,OAAS,UAAY,EAAW,OAAS,OACnG,CAEA,SAAS,GAAsB,EAAyB,EAAuD,CAC7G,IAAM,EAAS,EAAe,OAIxB,EADS,EAAe,cAAc,OAAQ,GAAU,EAAM,OAAS,SACrD,CAAC,CAAC,UAAW,GAAU,EAAM,KAAO,EAAK,EAAE,EAC/D,MAAC,GAAU,IAAe,IAI9B,IAAI,EAAO,OAAS,wBAAyB,CAC3C,IAAM,EAAU,EAAO,kBAAkB,MAAM,CAAC,EAAE,cAAc,OAAQ,GAAU,EAAM,OAAS,SAAS,EAC1G,OAAO,GAAgB,IAAU,EAAW,CAC9C,CAEA,GAAI,EAAO,OAAS,WAAY,CAC9B,IAAM,EAAS,EAAwB,EAAQ,MAAM,CAAC,CAAC,GACvD,OAAO,GAAgB,CAAM,CAC/B,CALA,CAQF,CAGA,SAAS,GAAgB,EAA2D,CAClF,OAAO,GAAQ,OAAS,cAAgB,EAAO,OAAS,IAAM,EAAO,KAAO,IAAA,EAC9E,CAEA,SAAS,GAAyB,EAA6C,CAC7E,IAAI,EAAyC,EAC7C,KAAO,GAAS,CACd,IAAM,EAA0C,EAAQ,OAClD,EAAiD,GAAe,OAKtE,GAJI,GAAe,OAAS,aAAe,GAAU,OAAS,mBAI1D,CAAC,GAA4B,CAAQ,EACvC,OAGF,IAAM,EAAiB,EAAS,OAChC,GAAI,GAAgB,OAAS,sBAC3B,OAAO,EAAe,kBAAkB,MAAM,CAAC,EAAE,KAGnD,EAAU,CACZ,CAGF,CAEA,SAAS,GAA4B,EAAkC,CACrE,IAAM,EAAa,EAAK,kBAAkB,UAAU,GAAK,EAAK,WAAW,CAAC,EAC1E,OACE,GAAY,OAAS,QACrB,GAAY,OAAS,cACrB,GAAY,OAAS,cACrB,GAAY,OAAS,kBAEzB,CAEA,SAAS,EAAW,EAAkC,CACpD,OACE,EAAK,OAAS,mBACd,EAAK,OAAS,QACd,EAAK,OAAS,qBACd,EAAK,OAAS,oBAGd,EAAK,OAAS,kBACd,EAAK,OAAS,8BACd,EAAK,OAAS,iCAElB,CAGA,SAAS,GAA4B,EAA6C,CAEhF,IAAK,IAAM,KAAS,EAAK,SACvB,GAAI,EAAM,OAAS,QAAS,CAC1B,IAAM,EAAe,EAAM,SAAS,KAAM,GAAe,EAAW,OAAS,eAAe,EAC5F,GAAI,EACF,OAAO,EAAa,IAExB,CAGF,IAAM,EAAS,EAAK,kBAAkB,UAAU,EAChD,GAAI,GAAQ,OAAS,mBAAoB,CACvC,IAAM,EAAa,EAAO,SAAS,UAAW,GAAU,EAAM,OAAS,SAAW,EAAM,OAAS,UAAU,EACrG,EAAY,IAAe,GAAK,IAAA,GAAY,EAAO,SAAS,EAAa,GAC/E,GAAI,GAAW,OAAS,oBAAsB,GAAW,OAAS,iBAChE,MAAO,YAAY,EAAU,MAEjC,CAEF,CAGA,MAAM,GAA6B,IAAI,IAAI,CACzC,iBACA,sBACA,WACA,SACA,oBACA,qBACA,eACA,oBACF,CAAC,EAED,SAAS,GAAe,EAA6C,CASnE,GAAI,EAAK,OAAS,OAAQ,CACxB,IAAM,EAAa,EAAK,kBAAkB,QAAQ,EAC5C,EAAe,EAAK,kBAAkB,UAAU,EACtD,GAAI,GAAY,OAAS,QAAU,GAAc,OAAS,aACxD,OAAO,EAAa,KAGtB,GAAI,GAAc,EAAK,QAAQ,OAAS,cAAgB,EAAK,OAAO,kBAAkB,MAAM,CAAC,EAAE,KAAO,EAAK,GACzG,MAAO,GAAG,EAAW,KAAK,GAG5B,GAAI,GAAY,OAAS,WACvB,OAAO,EAAW,IAEtB,CAKA,GAAI,EAAK,OAAS,kBAAmB,CACnC,IAAM,EAAe,GAA4B,CAAI,EACrD,GAAI,EACF,OAAO,CAEX,CAEA,IAAM,EACJ,EAAK,kBAAkB,UAAU,GACjC,EAAK,kBAAkB,MAAM,GAC7B,EAAK,kBAAkB,QAAQ,GAE/B,EAAK,kBAAkB,aAAa,GACpC,EAAK,kBAAkB,MAAM,GAC7B,EAAK,WAAW,CAAC,EACnB,GAAI,CAAC,EACH,OAKF,IAAM,EAAkB,GAA8B,CAAU,EAC5D,OAA2B,IAAI,EAAgB,IAAI,EAIvD,OAAO,EAAwB,CAAe,CAChD,CAEA,SAAS,GAA8B,EAA4C,CACjF,IAAI,EAAU,EACd,KAAO,EAAQ,OAAS,4BAA8B,EAAQ,kBAAoB,GAAG,CACnF,IAAM,EAAQ,EAAQ,WAAW,CAAC,EAClC,GAAI,CAAC,EACH,MAEF,EAAU,CACZ,CACA,OAAO,CACT,CAGA,MAAM,GAA8B,IAAI,IAAI,CAC1C,qBACA,yBACA,cACA,iBAEA,kBACF,CAAC,EAED,SAAS,GAA2B,EAAyB,EAAuB,CAClF,GAAI,IAAS,IAAK,CAEhB,IAAM,EAAa,EAAK,QAAQ,KAChC,OAAO,IAAe,mBAAqB,IAAe,sBAC5D,CACA,GAAI,IAAS,IACX,MAAO,GAET,IAAM,EAAa,EAAK,QAAQ,KAChC,OAAO,IAAe,IAAA,IAAa,GAA4B,IAAI,CAAU,CAC/E,CAEA,SAAS,EAAwB,EAA6C,CAI5E,GAAI,EAAK,OAAS,oBAAsB,EAAK,OAAS,qBAAuB,EAAK,OAAS,kBAAmB,CAC5G,IAAM,EAAa,EAAK,kBAAkB,UAAU,GAAK,EAAK,kBAAkB,MAAM,EACtF,GAAI,EACF,OAAO,EAAwB,CAAU,CAE7C,CAGA,GAAI,EAAK,OAAS,kBAChB,OAAO,EAAK,KAKd,GAAI,EAAK,OAAS,eAAgB,CAChC,IAAM,EAAW,EAAK,cAAc,KACjC,GAAU,EAAM,OAAS,mBAAqB,EAAM,OAAS,wBAChE,EACA,GAAI,EACF,OAAO,EAAwB,CAAQ,CAE3C,CAEA,GACE,EAAK,OAAS,cACd,EAAK,OAAS,uBACd,EAAK,OAAS,oBACd,EAAK,OAAS,mBACd,EAAK,OAAS,YAEd,OAAO,EAAK,KAGd,IAAK,IAAI,EAAQ,EAAK,gBAAkB,EAAG,GAAS,EAAG,IAAY,CACjE,IAAM,EAAQ,EAAK,WAAW,CAAK,EACnC,GAAI,CAAC,EACH,SAGF,IAAM,EAAa,EAAwB,CAAK,EAChD,GAAI,EACF,OAAO,CAEX,CAGF,CAEA,SAAS,GAAyB,EAAkC,CAClE,GAAI,CAAC,EAAW,CAAI,EAClB,MAAO,GAGT,IAAM,EAAa,EAAK,kBAAkB,UAAU,GAAK,EAAK,WAAW,CAAC,EAC1E,OAAO,GAAY,OAAS,uBAAyB,GAAY,OAAS,eAC5E,CAEA,SAAS,GAAa,EAAkC,CACtD,OACE,EAAK,OAAS,oBACd,EAAK,OAAS,sBACd,EAAK,OAAS,yBACd,EAAK,OAAS,eACd,EAAK,OAAS,oBACd,EAAK,OAAS,mBACd,EAAK,OAAS,4BAEd,EAAK,OAAS,6BACd,EAAK,OAAS,iBAElB,CAEA,SAAS,GAAmB,EAAyB,EAAuC,CAC1F,OACE,GAAa,CAAI,GACjB,GAAqB,EAAM,CAAQ,GACnC,EAAkB,EAAM,CAAQ,GAChC,EAAoB,CAAI,GACxB,EAAkB,EAAM,CAAQ,GAC/B,GAAa,CAAI,GAAK,EAAK,kBAAkB,QAAQ,IAAM,IAEhE,CAOA,SAAS,EAAkB,EAAyB,EAAuC,CACzF,GAAI,EAAS,OAAS,MACpB,MAAO,GAET,GAAI,EAAK,OAAS,cAAe,CAC/B,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAO9C,OANI,GAAU,OAAS,kBAGnB,EAAS,OAAS,SACb,CAAC,GAAoB,EAAM,QAAQ,EAErC,EAAS,OAAS,UAAY,sBAAsB,KAAK,EAAK,IAAI,EALhE,EAMX,CAIA,OAHI,EAAK,OAAS,qBAAuB,EAAK,OAAS,uBAC9C,EAAK,QAAQ,OAAS,oBAAsB,mBAAmB,KAAK,EAAK,IAAI,EAE/E,EACT,CAGA,SAAS,GAAqB,EAAyB,EAAuC,CAC5F,OAAO,EAAS,OAAS,QAAU,EAAK,OAAS,YAAc,CAAC,EAAK,kBAAkB,MAAM,CAC/F,CAEA,SAAS,EAAoB,EAAkC,CAM7D,OALK,EAAW,CAAI,GAID,EAAK,kBAAkB,UAAU,GAAK,EAAK,WAAW,CAAC,EAAA,EACvD,OAAS,SAJnB,EAKX,CAEA,SAAS,GACP,EACA,EACA,EACU,CACV,GAAI,EAAS,OAAS,SAAU,CAC9B,IAAM,EAAgB,GAAwB,EAAM,CAAO,EAC3D,GAAI,EAAc,OAAS,EACzB,OAAO,CAEX,CAEA,GAAI,EAAS,OAAS,OACpB,OAAO,GAAsB,CAAI,EAInC,GAAI,EAAS,OAAS,QAAU,EAAK,OAAS,4BAA6B,CACzE,IAAM,EAAa,EAAK,kBAAkB,QAAQ,EAClD,OAAO,EAAa,CAAC,EAAsB,EAAW,IAAI,CAAC,EAAI,CAAC,CAClE,CAEA,GAAI,EAAS,OAAS,QAAU,EAAK,OAAS,qBAAsB,CAClE,IAAM,EAAe,EAAK,WAAW,CAAC,EACtC,GAAI,CAAC,EACH,MAAO,CAAC,EAKV,IAAM,EAAW,EAAK,SAAS,KAAM,GAAU,EAAM,OAAS,QAAQ,EAChE,EAAa,EAAK,cAAc,KAAM,GAAU,EAAM,OAAS,UAAU,EACzE,EAAS,EAAsB,EAAa,IAAI,EACtD,MAAO,CAAC,GAAc,CAAC,EAAW,GAAG,EAAO,IAAM,CAAM,CAC1D,CAIA,GAAI,EAAkB,EAAM,CAAQ,EAAG,CAErC,IAAM,EADQ,qDAAqD,KAAK,EAAK,IAC1D,CAAC,GAAG,GAIvB,OAHK,EAGE,EAAO,WAAW,GAAG,EAAI,CAAC,KAAK,EAAQ,CAAM,GAAG,EAAI,CAAC,CAAM,EAFzD,CAAC,CAGZ,CAEA,GAAI,EAAkB,EAAM,CAAQ,EAClC,OAAO,GAAuB,CAAI,EAKpC,GAAI,EAAK,OAAS,kBAAmB,CACnC,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAC9C,GAAI,CAAC,EACH,MAAO,CAAC,EAEV,IAAM,EAAS,EAAQ,EAAS,IAAI,EAEpC,MAAO,CADS,EAAS,OAAS,kBAAoB,CAAC,EAAO,WAAW,GAAG,GAAK,CAAC,EAAO,WAAW,GAAG,EACrF,KAAK,IAAW,CAAM,CAC1C,CAEA,GAAI,EAAoB,CAAI,EAC1B,OAAO,GAAyB,CAAI,EAGtC,IAAM,EAAa,EAAK,kBAAkB,QAAQ,GAAK,GAAoB,CAAI,EAC/E,OAAO,EAAa,CAAC,EAAQ,EAAW,IAAI,CAAC,EAAI,CAAC,CACpD,CAEA,MAAM,GAAqB,IAAI,IAAI,CAAC,UAAW,mBAAoB,MAAM,CAAC,EAG1E,SAAS,EAAkB,EAAyB,EAAuC,CACzF,GAAI,EAAS,OAAS,QAAU,EAAK,OAAS,OAC5C,MAAO,GAGT,IAAM,EAAa,EAAK,kBAAkB,QAAQ,EAClD,GAAI,GAAY,OAAS,aACvB,MAAO,GAIT,GAAI,EAAW,OAAS,WAAY,CAClC,IAAM,EAAW,EAAK,kBAAkB,UAAU,EAClD,OAAO,IAAa,MAAQ,EAAS,OAAS,YAAc,EAAS,OAAS,kBAChF,CACA,OAAO,EAAK,kBAAkB,UAAU,IAAM,MAAQ,GAAmB,IAAI,EAAW,IAAI,CAC9F,CAGA,SAAS,GAAuB,EAAmC,CACjE,IAAM,EAAgB,EAAK,kBAAkB,WAAW,EAElD,EAAa,EAAK,kBAAkB,QAAQ,CAAC,EAAE,OAAS,WACxD,EAAgB,GAAe,WAAW,IAAkB,EAMlE,GALI,CAAC,GAAiB,EAAc,OAAS,UAKzC,EAAc,cAAc,KAAM,GAAU,EAAM,OAAS,eAAe,EAC5E,MAAO,CAAC,EAKV,IAAM,EAAe,EAAc,cAAc,OAC9C,GAAU,EAAM,OAAS,kBAAoB,EAAM,OAAS,iBAC/D,EACM,EACJ,EAAa,OAAS,EAClB,EACG,IAAK,GAAW,EAAM,OAAS,kBAAoB,GAAyB,EAAM,IAAI,EAAI,EAAM,IAAK,CAAC,CACtG,KAAK,EAAE,EACV,EAAQ,EAAc,IAAI,EAOhC,OANmB,EAAK,kBAAkB,QAAQ,CAAC,EAAE,OAAS,mBAErD,CAAC,EAAO,WAAW,GAAG,EAAI,EAAS,KAAK,GAAQ,EAIlD,CAAC,EAAO,QAAQ,iBAAkB,EAAE,CAAC,CAC9C,CAEA,MAAM,GAAuB,IAAI,IAAI,CACnC,CAAC,IAAK;CAAI,EACV,CAAC,IAAK,GAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,IAAI,CACZ,CAAC,EAGD,SAAS,GAAyB,EAAsB,CACtD,IAAM,EAAU,EAAK,MAAM,CAAC,EAC5B,OAAO,GAAqB,IAAI,CAAO,GAAK,CAC9C,CAEA,SAAS,GAAyB,EAAmC,CAEnE,IAAM,EADgB,EAAK,kBAAkB,WACX,CAAC,EAAE,WAAW,CAAC,EACjD,OAAO,GAAiB,GAAa,CAAa,EAAI,CAAC,EAAQ,EAAc,IAAI,CAAC,EAAI,CAAC,CACzF,CAEA,SAAS,GAAuB,EAAgB,EAAiC,CAO/E,OANI,EAAO,WAAW,GAAG,GAAK,EAAO,WAAW,GAAG,EAC1C,GAKF,IAAa,QAAU,EAAwB,CAAM,CAC9D,CAGA,SAAS,EAAwB,EAAyB,CACxD,MAAO,iCAAiC,KAAK,CAAM,CACrD,CAQA,SAAS,GAAsB,EAAmC,CAEhE,GAAI,EAAK,OAAS,WAAY,CAC5B,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAC9C,OAAO,EAAW,CAAC,SAAS,EAAsB,EAAS,IAAI,GAAG,EAAI,CAAC,CACzE,CAEA,GAAI,EAAK,OAAS,2BAA4B,CAC5C,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAC9C,OAAO,EAAW,CAAC,EAAsB,EAAS,IAAI,CAAC,EAAI,CAAC,CAC9D,CAEA,IAAM,EAAW,EAAK,kBAAkB,UAAU,EAClD,OAAO,EAAW,EAAkB,EAAU,EAAE,EAAI,CAAC,CACvD,CAGA,SAAS,EAAkB,EAAyB,EAA0B,CAC5E,OAAQ,EAAK,KAAb,CACE,IAAK,WACH,OAAO,EAAK,cAAc,QAAS,GAAU,EAAkB,EAAO,CAAM,CAAC,EAE/E,IAAK,kBAAmB,CACtB,IAAM,EAAW,EAAK,kBAAkB,MAAM,EACxC,EAAa,EAAe,EAAQ,EAAa,EAAK,kBAAkB,MAAM,CAAC,CAAC,EACtF,OAAO,EAAW,EAAkB,EAAU,CAAU,EAAI,EAAiB,CAAU,CACzF,CACA,IAAK,oBAAqB,CAGxB,IAAM,EAAW,EAAe,EAAQ,EAAsB,EAAK,IAAI,CAAC,EAKxE,OAJI,EAAwB,CAAQ,EAC3B,EAAiB,CAAQ,EAG3B,EAAiB,EAAe,EAAQ,EAAa,EAAK,kBAAkB,MAAM,CAAC,CAAC,CAAC,CAC9F,CACA,IAAK,eAEH,OAAO,EAAiB,EAAe,EAAQ,EAAa,EAAK,WAAW,CAAC,CAAC,CAAC,CAAC,EAElF,IAAK,gBAAiB,CACpB,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAC9C,OAAO,EAAW,EAAkB,EAAU,CAAM,EAAI,CAAC,CAC3D,CACA,IAAK,OAEH,OAAO,EAAiB,CAAM,EAEhC,IAAK,aACL,IAAK,QACL,IAAK,QAOH,OAJI,EAAK,OAAS,cAAgB,EAAwB,CAAM,EACvD,EAAiB,EAAe,EAAQ,EAAsB,EAAK,IAAI,CAAC,CAAC,EAG3E,EAAiB,IAAW,GAAK,EAAsB,EAAK,IAAI,EAAI,CAAM,EAEnF,QACE,MAAO,CAAC,CAEZ,CACF,CAEA,SAAS,EAAa,EAAwC,CAC5D,OAAO,EAAO,EAAsB,EAAK,IAAI,EAAI,EACnD,CAEA,SAAS,EAAe,EAAgB,EAAyB,CAI/D,OAHK,EAGE,EAAS,GAAG,EAAO,IAAI,IAAY,EAFjC,CAGX,CAEA,SAAS,EAAiB,EAA0B,CAClD,OAAO,EAAS,CAAC,CAAM,EAAI,CAAC,CAC9B,CAEA,SAAS,GAAwB,EAAyB,EAAwD,CAChH,GAAI,EAAK,OAAS,wBAAyB,CACzC,IAAM,EAAa,EAAK,kBAAkB,aAAa,EACvD,GAAI,CAAC,EACH,MAAO,CAAC,EAGV,IAAM,EAAe,EAAsB,EAAW,IAAI,EACpD,EAAY,EAAwB,EAAM,MAAM,EACtD,GAAI,CAAC,EAAQ,wBAA0B,CAAC,EAAa,WAAW,GAAG,EACjE,MAAO,CAAC,CAAY,EAEtB,GAAI,SAAS,KAAK,CAAY,GAAK,EAAU,OAAS,EACpD,OAAO,EAAU,QAAQ,CAAqB,CAAC,CAAC,IAAK,GAAS,GAAG,IAAe,GAAM,EAExF,IAAM,EAAmB,EAAU,QAAQ,CAAqB,CAAC,CAAC,IAAK,GAAS,GAAG,EAAa,GAAG,GAAM,EAIzG,OAHI,EAAiB,OAAS,EACrB,CAAC,EAAc,GAAG,CAAgB,EAEpC,CAAC,CAAY,CACtB,CAMA,OAJI,EAAK,OAAS,mBAIX,EAAK,cACT,IAAK,GAAU,GAA6B,CAAK,CAAC,CAAC,CACnD,OAAQ,GAAW,IAAW,IAAA,EAAS,EALjC,CAAC,CAMZ,CAEA,SAAS,EAAsB,EAAmC,CAChE,GAAI,EAAK,OAAS,iBAAkB,CAClC,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAC9C,OAAO,EAAW,EAAsB,CAAQ,EAAI,CAAC,CACvD,CAUA,OARI,EAAK,OAAS,aACT,CAAC,EAAK,IAAI,EAGf,EAAK,OAAS,cACT,CAAC,EAAsB,EAAK,IAAI,CAAC,EAGnC,EAAK,cAAc,QAAQ,CAAqB,CACzD,CAEA,SAAS,EAAwB,EAAyB,EAAwC,CAChG,IAAM,EAAgC,CAAC,EACvC,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAK,WAAY,GAAS,EAAG,CACvD,IAAM,EAAQ,EAAK,MAAM,CAAK,EAC1B,GAAS,EAAK,kBAAkB,CAAK,IAAM,GAC7C,EAAS,KAAK,CAAK,CAEvB,CACA,OAAO,CACT,CAEA,SAAS,GAA6B,EAA6C,CACjF,GAAI,EAAK,OAAS,eAAiB,EAAK,OAAS,kBAC/C,OAAO,EAAsB,EAAK,IAAI,EAGxC,IAAM,EAAW,EAAK,kBAAkB,MAAM,EAC9C,GAAI,EACF,OAAO,EAAsB,EAAS,IAAI,EAG5C,IAAK,IAAM,KAAS,EAAK,cAAe,CACtC,IAAM,EAAS,GAA6B,CAAK,EACjD,GAAI,EACF,OAAO,CAEX,CAGF,CAEA,SAAS,EAAsB,EAAwB,CACrD,OAAO,EAAO,WAAW,QAAS,EAAE,CACtC,CAEA,SAAS,GAAoB,EAAwD,CACnF,GAAI,GAAa,CAAI,EACnB,OAAO,EAGT,IAAK,IAAM,KAAS,EAAK,cAAe,CACtC,IAAM,EAAa,GAAoB,CAAK,EAC5C,GAAI,EACF,OAAO,CAEX,CAGF,CAEA,SAAS,GAAa,EAAkC,CACtD,OAAO,EAAK,OAAS,UAAY,EAAK,OAAS,kBAAoB,EAAK,OAAS,4BACnF,CAEA,SAAS,EAAQ,EAAuB,CACtC,OAAO,EAAM,WAAW,oBAAqB,EAAE,CACjD,CAEA,SAAS,GAAa,EAAkC,CAEtD,OACG,EAAK,KAAK,WAAW,QAAQ,GAAK,EAAK,OAAS,4BACjD,EAAK,OAAS,yBAElB,CAEA,SAAS,GAAqB,EAA8C,CAC1E,IAAM,EAAmB,IAAI,IAE7B,IAAK,IAAM,KAAS,EAAM,KAAK,EACzB,GAAS,EAAO,EAAO,EAAO,IAAI,GAAK,GACzC,EAAiB,IAAI,CAAK,EAI9B,OAAO,CACT,CAEA,SAAS,GAAS,EAAe,EAAgB,EAAiC,EAA+B,CAC/G,IAAM,EAAU,EAAM,IAAI,CAAK,EAC/B,GAAI,CAAC,EACH,MAAO,GAGT,IAAK,IAAM,KAAU,EAKnB,GAJI,IAAW,GAIX,CAAC,EAAQ,IAAI,CAAM,IACrB,EAAQ,IAAI,CAAM,EACd,GAAS,EAAQ,EAAQ,EAAO,CAAO,GACzC,MAAO,GAKb,MAAO,EACT,CAEA,SAAS,GAAoB,EAAyC,CACpE,IAAM,EAAe,IAAI,IACrB,EAAW,EACf,IAAK,IAAM,KAAS,EAAM,KAAK,EAC7B,EAAW,KAAK,IAAI,EAAU,GAAiB,EAAO,EAAO,IAAI,IAAO,CAAY,CAAC,CAAC,KAAK,EAE7F,OAAO,CACT,CAQA,SAAS,GACP,EACA,EACA,EACA,EACqC,CACrC,IAAM,EAAW,EAAa,IAAI,CAAK,EACvC,GAAI,IAAa,IAAA,GACf,MAAO,CAAE,MAAO,EAAU,QAAS,EAAM,EAE3C,IAAM,EAAU,EAAM,IAAI,CAAK,EAC/B,GAAI,CAAC,GAAW,EAAQ,OAAS,EAC/B,MAAO,CAAE,MAAO,EAAG,QAAS,EAAM,EAEpC,GAAI,EAAY,IAAI,CAAK,EACvB,MAAO,CAAE,MAAO,EAAG,QAAS,EAAK,EAGnC,EAAY,IAAI,CAAK,EACrB,IAAI,EAAW,EACX,EAAU,GACd,IAAK,IAAM,KAAU,EAAS,CAC5B,IAAM,EAAS,GAAiB,EAAQ,EAAO,EAAa,CAAY,EACxE,EAAW,KAAK,IAAI,EAAU,EAAI,EAAO,KAAK,EAC9C,IAAY,EAAO,OACrB,CAKA,OAJA,EAAY,OAAO,CAAK,EACnB,GACH,EAAa,IAAI,EAAO,CAAQ,EAE3B,CAAE,MAAO,EAAU,SAAQ,CACpC,CAEA,SAAS,GAAkB,EAAmB,EAA4B,CACxE,GAAM,CAAC,EAAS,GAAU,EAAK,MAAQ,EAAM,KAAO,CAAC,EAAM,CAAK,EAAI,CAAC,EAAO,CAAI,EAC5E,EAAQ,EACZ,IAAK,IAAM,KAAS,EACd,EAAO,IAAI,CAAK,IAClB,GAAS,GAGb,OAAO,CACT,CAEA,SAAS,GAA8B,EAAgB,EAAoB,EAAqB,CAC9F,GAAI,IAAQ,EACV,MAAO,KAGT,IAAM,EAAM,IAAM,IAAM,KAAK,IAAI,KAAK,IAAI,EAAQ,CAAC,CAAC,EAAI,IAAO,EAAa,KAAO,KAAK,IAAI,CAAG,EAC/F,OAAO,KAAK,IAAI,EAAG,KAAK,IAAI,IAAM,EAAM,IAAO,GAAG,CAAC,CACrD,CAEA,SAAS,EAAe,EAA0B,EAAqB,CACrE,EAAI,IAAI,GAAQ,EAAI,IAAI,CAAK,GAAK,GAAK,CAAC,CAC1C,CAEA,SAAS,GAAU,EAA8B,EAA6D,CAC5G,OAAO,EAAU,SAAW,EAAI,EAAI,KAAK,IAAI,GAAG,EAAU,IAAK,GAAO,EAAG,EAAI,CAAC,CAChF,CAEA,SAAS,EAAY,EAAmC,CACtD,IAAI,EAAU,EACd,IAAK,IAAM,KAAS,EAAI,OAAO,EAC7B,EAAU,KAAK,IAAI,EAAS,CAAK,EAEnC,OAAO,CACT,CAEA,SAAS,EAAI,EAAkC,CAC7C,IAAI,EAAQ,EACZ,IAAK,IAAM,KAAS,EAClB,GAAS,EAEX,OAAO,CACT"}