analyzer

type AggregateComplexity struct {
	TotalFunctions    int
	AverageComplexity float64
	MaxComplexity     int
	MinComplexity     int
	HighRiskCount     int
	MediumRiskCount   int
	LowRiskCount      int
}

type AggregateRawMetrics struct {
	FilesAnalyzed  int
	SLOC           int
	LLOC           int
	CommentLines   int
	DocstringLines int
	BlankLines     int
	TotalLines     int
	CommentRatio   float64
}

type BasicBlock = corecfg.BasicBlock

type BridgeModuleMetrics struct {
	Module              string
	CommunityID         string
	CrossCommunityEdges int
	TargetCommunities   []string
}

type CBOAnalyzer struct {
	// contains filtered or unexported fields
}

type CBOOptions struct {
	IncludeBuiltins       bool
	IncludeImports        bool
	PublicClassesOnly     bool
	GroupNamespaceImports bool
	ExcludePatterns       []string
	LowThreshold          int // Default: 3 (industry standard)
	MediumThreshold       int // Default: 7 (industry standard)
}

type CBOResult struct {
	// Core CBO metric
	CouplingCount int

	// Class information
	ClassName string
	FilePath  string
	StartLine int
	EndLine   int

	// Dependency breakdown
	InheritanceDependencies     int
	TypeHintDependencies        int
	InstantiationDependencies   int
	AttributeAccessDependencies int
	ImportDependencies          int

	// Detailed dependency list
	DependentClasses []string

	// Risk assessment
	RiskLevel string // "low", "medium", "high"

	// Additional class metadata
	IsAbstract  bool
	BaseClasses []string
	Methods     []string
	Attributes  []string
}

type CFG = corecfg.CFG

type CFGBuilder struct {
	// contains filtered or unexported fields
}

type CFGFeatures struct {
	BlockCount       int              // Number of basic blocks
	EdgeCount        int              // Number of edges
	EdgeTypeCounts   map[EdgeType]int // Distribution of edge types
	CyclomaticNumber int              // Cyclomatic complexity: V(G) = E - N + 2P
	BranchingFactor  float64          // Average number of successors per block
	LoopEdgeCount    int              // Number of loop back-edges
	ConditionalCount int              // Number of conditional branches
}

type CFGScope struct {
	Kind        domain.AnalysisScopeKind
	Name        string
	StartLine   int
	StartColumn int
}

type CFGVisitor = corecfg.Visitor

type CircularDependency struct {
	Modules      []string          // Modules involved in the cycle
	Dependencies []DependencyChain // The dependency chains that form the cycle
	Severity     CycleSeverity     // Severity level of this cycle
	Size         int               // Number of modules in the cycle
	Description  string            // Human-readable description
}

type CircularDependencyDetector struct {
	// contains filtered or unexported fields
}

type CircularDependencyResult struct {
	HasCircularDependencies bool                  // True if any cycles were found
	TotalCycles             int                   // Total number of cycles detected
	TotalModulesInCycles    int                   // Total number of modules involved in cycles
	CircularDependencies    []*CircularDependency // All detected circular dependencies

	// Severity breakdown
	LowSeverityCycles      int // Number of low severity cycles
	MediumSeverityCycles   int // Number of medium severity cycles
	HighSeverityCycles     int // Number of high severity cycles
	CriticalSeverityCycles int // Number of critical severity cycles

	// Most problematic cycles
	LargestCycle       *CircularDependency // Cycle with most modules
	MostComplexCycle   *CircularDependency // Cycle with most dependency chains
	CoreInfrastructure []string            // Modules that appear in multiple cycles
}

type ClassificationResult struct {
	CloneType  CloneType
	Similarity float64
	Confidence float64
	Analyzer   string
}

type CloneClassifier struct {
	// contains filtered or unexported fields
}

type CloneClassifierConfig struct {
	Type1Threshold         float64
	Type2Threshold         float64
	Type3Threshold         float64
	Type4Threshold         float64
	EnableTextualAnalysis  bool
	EnableSemanticAnalysis bool
	EnableDFAAnalysis      bool // Enable Data Flow Analysis for enhanced Type-4 detection
}

type CloneDetectionResult struct {
	Pairs      []*ClonePair
	Groups     []*CloneGroup
	Statistics *CloneDetectionStatistics
}

type CloneDetectionStatistics struct {
	TotalFragments    int
	TotalClones       int
	TotalClonePairs   int
	TotalCloneGroups  int
	ClonesByType      map[string]int
	AverageSimilarity float64
}

type CloneDetector struct {
	// contains filtered or unexported fields
}

type CloneDetectorConfig struct {
	// Minimum number of lines for a code fragment to be considered
	MinLines int

	// Minimum number of AST nodes for a code fragment
	MinNodes int

	// Similarity thresholds for different clone types
	Type1Threshold float64 // Usually > domain.DefaultType1CloneThreshold
	Type2Threshold float64 // Usually > domain.DefaultType2CloneThreshold
	Type3Threshold float64 // Usually > domain.DefaultType3CloneThreshold
	Type4Threshold float64 // Usually > domain.DefaultType4CloneThreshold

	// Minimum similarity threshold for clone reporting (user-configurable via --clone-threshold)
	SimilarityThreshold float64

	// Maximum edit distance allowed
	MaxEditDistance float64

	// Whether to ignore differences in literals
	IgnoreLiterals bool

	// Whether to ignore differences in identifiers
	IgnoreIdentifiers bool

	// Whether to skip docstrings from AST comparison (default: true)
	// Docstrings are the first Expr(Constant(str)) in function/class/module bodies
	SkipDocstrings bool

	// Cost model to use for APTED
	CostModelType string // "default", "python", "weighted"

	// Performance tuning parameters
	MaxClonePairs      int // Maximum pairs to keep in memory
	BatchSizeThreshold int // Minimum fragments to trigger batching
	BatchSizeLarge     int // Batch size for normal projects
	BatchSizeSmall     int // Batch size for large projects
	LargeProjectSize   int // Fragment count threshold for large projects
	MaxGoroutines      int // Goroutines for parallel pair comparison (0 = all CPUs)

	// Grouping configuration
	GroupingMode      GroupingMode // Default: GroupingModeConnected
	GroupingThreshold float64      // Default: Type3Threshold
	KCoreK            int          // Default: 2

	// LSH Configuration (optional, opt-in)
	UseLSH                 bool    // Enable LSH acceleration
	LSHSimilarityThreshold float64 // Candidate threshold using MinHash similarity
	LSHBands               int     // Number of LSH bands (default: 32)
	LSHRows                int     // Rows per band (default: 4)
	LSHMinHashCount        int     // Number of MinHash functions (default: 128)
	LSHMaxCandidates       int     // Maximum candidates returned per LSH query

	// Multi-dimensional classification (optional, opt-in)
	EnableMultiDimensionalAnalysis bool // Enable multi-dimensional clone type classification
	EnableTextualAnalysis          bool // Enable Type-1 textual analysis (increases memory usage)
	EnableSemanticAnalysis         bool // Enable Type-4 semantic/CFG analysis (increases CPU usage)
	EnableDFAAnalysis              bool // Enable Data Flow Analysis for enhanced Type-4 detection

	// Framework pattern handling (reduces false positives for dataclass, Pydantic, etc.)
	ReduceBoilerplateSimilarity bool    // Apply lower weight to boilerplate nodes (default: true)
	BoilerplateMultiplier       float64 // Cost multiplier for boilerplate nodes (default: 0.1)
}

type CloneGroup struct {
	ID         int             // Unique identifier for this group
	Fragments  []*CodeFragment // All fragments in this group
	CloneType  CloneType       // Primary type of clones in this group
	Similarity float64         // Average similarity within the group
	Size       int             // Number of fragments
}

type ClonePair struct {
	Fragment1  *CodeFragment
	Fragment2  *CodeFragment
	Similarity float64   // Similarity score (0.0 to 1.0)
	Distance   float64   // Edit distance
	CloneType  CloneType // Type of clone detected
	Confidence float64   // Confidence in the detection (0.0 to 1.0)
}

type CloneType int

type CodeFragment struct {
	Location   *CodeLocation
	ASTNode    *parser.Node
	TreeNode   *coreapted.TreeNode
	Content    string   // Original source code content
	Hash       string   // FNV-64a hex hash of Type-1 normalized content; "" when no source content
	Size       int      // Number of AST nodes
	LineCount  int      // Number of source lines
	Complexity int      // Cyclomatic complexity (if applicable)
	Features   []string // Detector-populated clone feature cache for this fragment's tree
	// contains filtered or unexported fields
}

type CodeLocation struct {
	FilePath  string
	StartLine int
	EndLine   int
	StartCol  int
	EndCol    int
}

type CognitiveComplexityResult struct {
	// Total cognitive complexity score
	Total int

	// Function/method information
	FunctionName string
	StartLine    int
	EndLine      int
}

type CommunityDirectedEdge struct {
	FromIndex int
	ToIndex   int
	Weight    float64
	IsLazy    bool
}

type CommunityGraph struct {
	NodeCount   int
	NodeNames   []string
	NameToIndex map[string]int

	// UndirectedAdj holds weighted undirected adjacency lists for clustering.
	// Each neighbor list is sorted by index for deterministic iteration.
	UndirectedAdj [][]WeightedNeighbor

	// DirectedEdges preserves directed import edges for cross-community
	// in/out counts. Not collapsed into undirected form.
	DirectedEdges []CommunityDirectedEdge

	// TotalUndirectedWeight is the sum of undirected edge weights (each
	// undirected pair counted once). Used as a modularity denominator hook.
	TotalUndirectedWeight float64
}

type CommunityGraphBuildOptions struct {
	// ExcludeLazyEdges omits lazy (function-body) import edges when true.
	// Default false (lazy edges included). Exclusion uses the same criterion
	// as circular dependency detection (issue #460).
	ExcludeLazyEdges bool

	// EdgeWeightFunc assigns a weight to each dependency edge. When nil, every
	// edge has weight 1.0. Reserved for future weighting by import type,
	// frequency, or laziness.
	EdgeWeightFunc func(edge *DependencyEdge) float64
}

type CommunityPartition struct {
	ID                          string
	Modules                     []string
	Packages                    []string
	InternalEdges               int
	ExternalEdges               int
	ExternalDependencyRatio     float64
	IncomingCrossCommunityEdges int
	OutgoingCrossCommunityEdges int
	Size                        int

	DominantPackage  string
	PackageCount     int
	PackageAlignment float64

	DominantLayer  string
	LayerCount     int
	Layers         []string
	LayerAlignment float64
}

type CommunityPartitionMetrics struct {
	Communities      []CommunityPartition
	BridgeModules    []BridgeModuleMetrics
	TotalCommunities int
	Modularity       float64
}

type ComplexityAnalyzer struct {
	// contains filtered or unexported fields
}

type ComplexityResult struct {
	// McCabe cyclomatic complexity
	Complexity int

	// Raw CFG metrics
	Edges               int
	Nodes               int
	ConnectedComponents int

	// Function/method information
	FunctionName string
	StartLine    int
	StartCol     int
	EndLine      int

	// Nesting depth
	NestingDepth        int
	CognitiveComplexity int

	// Decision points breakdown
	IfStatements      int
	LoopStatements    int
	ExceptionHandlers int
	SwitchCases       int

	// SLOC is the source lines of code for this function.
	SLOC int

	// Risk assessment based on complexity thresholds
	RiskLevel string // "low", "medium", "high"
}

type ConcreteDependencyDetector struct {
	// contains filtered or unexported fields
}

type ConstructorAnalyzer struct {
	// contains filtered or unexported fields
}

type ControlFlowGraphs []ScopedCFG

type CouplingMetricsCalculator struct {
	// contains filtered or unexported fields
}

type CouplingMetricsOptions struct {
	IncludeAbstractness bool               // Calculate abstractness metrics
	ComplexityData      map[string]int     // Complexity data from complexity analysis
	ClonesData          map[string]float64 // Clone data from clone analysis
	DeadCodeData        map[string]int     // Dead code data from dead code analysis
}

type CycleSeverity string

type DFABuilder = coredfa.DFABuilder

type DFAFeatures struct {
	TotalDefs       int // Total number of definitions
	TotalUses       int // Total number of uses
	TotalPairs      int // Total number of def-use pairs
	UniqueVariables int // Number of unique variables

	AvgChainLength  float64 // Average uses per definition
	MaxChainLength  int     // Maximum def-use chain length
	CrossBlockPairs int     // Def-use pairs spanning blocks
	IntraBlockPairs int     // Def-use pairs within same block

	DefKindCounts map[DefUseKind]int // Distribution of definition kinds
	UseKindCounts map[DefUseKind]int // Distribution of use kinds
}

type DFAInfo = coredfa.DFAInfo

type DIAntipatternDetector struct {
	// contains filtered or unexported fields
}

type DIAntipatternOptions struct {
	ConstructorParamThreshold int
	MinSeverity               domain.DIAntipatternSeverity
}

type DeadCodeDetector struct {
	// contains filtered or unexported fields
}

type DeadCodeFinding struct {
	// Execution-scope information
	FunctionName string                   `json:"function_name"`
	ScopeKind    domain.AnalysisScopeKind `json:"scope_kind"`
	FilePath     string                   `json:"file_path"`

	// Location information
	StartLine int `json:"start_line"`
	EndLine   int `json:"end_line"`

	// Dead code details
	BlockID     string         `json:"block_id"`
	Code        string         `json:"code"`
	Reason      DeadCodeReason `json:"reason"`
	Severity    SeverityLevel  `json:"severity"`
	Description string         `json:"description"`

	// Context information
	Context []string `json:"context,omitempty"`
}

type DeadCodeReason string

type DeadCodeResult struct {
	// Execution-scope information
	FunctionName string                   `json:"function_name"`
	ScopeKind    domain.AnalysisScopeKind `json:"scope_kind"`
	FilePath     string                   `json:"file_path"`

	// Analysis results
	Findings       []*DeadCodeFinding `json:"findings"`
	TotalBlocks    int                `json:"total_blocks"`
	DeadBlocks     int                `json:"dead_blocks"`
	ReachableRatio float64            `json:"reachable_ratio"`

	// Performance metrics
	AnalysisTime time.Duration `json:"analysis_time"`
}

type DefUseChain = coredfa.DefUseChain

type DefUseKind = coredfa.DefUseKind

type DefUsePair = coredfa.DefUsePair

type DependencyChain struct {
	From   string   // Starting module
	To     string   // Ending module
	Path   []string // Complete dependency path
	Length int      // Length of the chain
}

type DependencyEdge struct {
	From       string             // Source module name
	To         string             // Target module name
	EdgeType   DependencyEdgeType // Type of dependency
	ImportInfo *ImportInfo        // Details about the import
	IsLazy     bool               // True if every import forming this edge is lazy (function/method-body)
}

type DependencyEdgeType string

type DependencyGraph struct {
	// Graph structure
	Nodes map[string]*ModuleNode // Module name -> ModuleNode
	Edges []*DependencyEdge      // All dependency relationships

	// Graph metadata
	TotalModules int // Total number of modules
	TotalEdges   int // Total number of dependencies
	// ResolvedImports and UnresolvedImports count internal import statements,
	// excluding standard-library and third-party imports that are not part of
	// the analyzed graph.
	ResolvedImports   int
	UnresolvedImports int
	RootModules       []string // Modules with no dependencies
	LeafModules       []string // Modules with no dependents
	ProjectRoot       string   // Project root directory

	// Analysis results
	CyclicGroups  [][]string                // Strongly connected components (cycles)
	ModuleMetrics map[string]*ModuleMetrics // Module-level metrics
	SystemMetrics *SystemMetrics            // System-wide metrics
	// contains filtered or unexported fields
}

type DependencyTopology struct {
	// contains filtered or unexported fields
}

type Edge = corecfg.Edge

type EdgeType = corecfg.EdgeType

type FileComplexityAnalyzer struct {
	// contains filtered or unexported fields
}

type GroupingMode string

type HiddenDependencyDetector struct {
	// contains filtered or unexported fields
}

type ImportInfo struct {
	Statement      string   // Original import statement
	ImportedNames  []string // Names imported (for from imports)
	Alias          string   // Alias used (if any)
	IsRelative     bool     // True for relative imports
	Level          int      // Level for relative imports (number of dots)
	Line           int      // Line number where import occurs
	IsTypeChecking bool     // True if import is inside a TYPE_CHECKING block
	IsLazy         bool     // True if import is inside a function/method body (not executed at module load)
}

type LCOMAnalyzer struct {
	// contains filtered or unexported fields
}

type LCOMOptions struct {
	LowThreshold    int // Default: 2 (LCOM4 <= 2 is low risk)
	MediumThreshold int // Default: 5 (LCOM4 3-5 is medium risk)
}

type LCOMResult struct {
	// Core LCOM4 metric - number of connected components
	LCOM4 int

	// Class information
	ClassName string
	FilePath  string
	StartLine int
	EndLine   int

	// Method statistics
	TotalMethods    int // All methods found in class
	ExcludedMethods int // @staticmethod/@classmethod/@abstractmethod and constructors excluded

	// Instance variable count
	InstanceVariables int // Distinct self.xxx variables

	// Connected component details
	MethodGroups [][]string // Method names grouped by connected component

	// Risk assessment
	RiskLevel string // "low", "medium", "high"
}

type LayerMismatchMetrics struct {
	LayerAlignmentScore   float64
	CrossLayerCommunities []string
	LayerBridgeModules    []string
}

type LeidenOptions struct {
	// Resolution scales the null-model term in the modularity quality
	// function (default 1.0). Higher values favour smaller communities.
	Resolution float64

	// MinCommunitySize merges communities smaller than this threshold into
	// a neighbouring community after detection (default 1, no merging).
	MinCommunitySize int

	// MaxIterations bounds local-moving sweeps per phase (default 64).
	MaxIterations int

	// MaxPasses bounds Leiden passes before stopping (default 16).
	MaxPasses int
}

type LeidenResult struct {
	// Membership maps node index to community id in [0, NumCommunities).
	Membership []int

	// Modularity is the final modularity Q of the partition.
	Modularity float64

	// NumCommunities is the number of distinct communities.
	NumCommunities int
}

type ModuleAnalysisOptions struct {
	ProjectRoot       string   // Project root directory
	PythonPath        []string // Additional Python path entries
	ModuleRoots       []string // Explicit captured module roots; nil discovers from disk
	ExcludePatterns   []string // Module patterns to exclude; nil uses defaults, empty disables excludes
	IncludePatterns   []string // Module patterns to include; nil uses defaults, empty includes all files
	IncludeStdLib     *bool    // Include standard library dependencies
	IncludeThirdParty *bool    // Include third-party dependencies
	FollowRelative    *bool    // Follow relative imports
}

type ModuleAnalyzer struct {
	// contains filtered or unexported fields
}

type ModuleMetrics struct {
	// Coupling metrics
	AfferentCoupling int     // Ca - Number of modules that depend on this module
	EfferentCoupling int     // Ce - Number of modules this module depends on
	Instability      float64 // I = Ce / (Ca + Ce) - Measure of instability
	Abstractness     float64 // A - Measure of abstractness (0-1)
	Distance         float64 // D - Distance from main sequence

	// Size metrics
	LinesOfCode        int // Total lines of code
	ClassCount         int // Number of classes
	AbstractClassCount int // Number of abstract classes
	PublicInterface    int // Number of public functions/classes

	// Quality metrics
	CyclomaticComplexity int // Average complexity of functions
}

type ModuleNode struct {
	// Module identification
	Name         string // Module name (e.g., "mypackage.submodule")
	FilePath     string // Absolute path to the Python file
	RelativePath string // Relative path from project root
	Package      string // Package name (e.g., "mypackage")
	IsPackage    bool   // True if this represents a package (__init__.py)

	// Dependencies
	Imports      []string        // Direct imports from this module
	ImportedBy   []string        // Modules that import this module
	Dependencies map[string]bool // Set of modules this module depends on
	Dependents   map[string]bool // Set of modules that depend on this module

	// LazyDependencies is the subset of Dependencies that is reachable ONLY via
	// lazy (function/method-body) imports — i.e. no module-load-time import to
	// the target exists. These edges are real runtime dependencies but cannot
	// form a load-time circular import, so circular-dependency detection skips
	// them. As soon as a module-level import to the same target is seen, the
	// entry is removed. See issue #460.
	LazyDependencies map[string]bool

	// Metrics
	InDegree  int // Number of incoming dependencies
	OutDegree int // Number of outgoing dependencies

	// Module information
	LineCount          int      // Total lines in the module
	FunctionCount      int      // Number of functions defined
	ClassCount         int      // Number of classes defined
	AbstractClassCount int      // Number of abstract classes defined
	PublicNames        []string // Public names exported by this module
}

type NestingDepthResult struct {
	// Maximum nesting depth found in the function
	MaxDepth int

	// Historical function/method metadata fields.
	FunctionName string
	StartLine    int
	EndLine      int

	// Location of deepest nesting (line number)
	DeepestNestingLine int
}

type PackageMismatchMetrics struct {
	PackageAlignmentScore float64
	SplitPackages         []string
	MixedCommunities      []string
}

type ParsedModule struct {
	// contains filtered or unexported fields
}

type PythonCostModel struct {
	// Base costs for different operations
	BaseInsertCost float64
	BaseDeleteCost float64
	BaseRenameCost float64

	// Whether to ignore differences in literal values
	IgnoreLiterals bool

	// Whether to ignore differences in identifier names
	IgnoreIdentifiers bool

	// Whether to reduce weight for boilerplate nodes (type annotations, decorators, Field() calls)
	ReduceBoilerplateWeight bool

	// Multiplier for boilerplate nodes (default: 0.1)
	BoilerplateMultiplier float64
}

type RawMetricsResult struct {
	FilePath       string
	SLOC           int
	LLOC           int
	CommentLines   int
	DocstringLines int
	BlankLines     int
	TotalLines     int
	CommentRatio   float64
	// contains filtered or unexported fields
}

type ReExportEntry struct {
	Name         string // The exported name (e.g., "SomeClass")
	SourceModule string // The actual source module (e.g., "pkg_a.module_x")
	SourceName   string // The name in the source module (may differ if aliased)
}

type ReExportMap struct {
	PackageName string                    // The package name (e.g., "pkg_a")
	Exports     map[string]*ReExportEntry // name -> source info
	AllDeclared []string                  // Names in __all__ if declared
	HasAllDecl  bool                      // True if __all__ is explicitly declared
}

type ReExportResolver struct {
	// contains filtered or unexported fields
}

type ReachabilityAnalyzer struct {
	// contains filtered or unexported fields
}

type ReachabilityResult struct {
	// ReachableBlocks contains blocks reachable from the CFG entry.
	ReachableBlocks map[string]*BasicBlock
	// UnreachableBlocks contains registered blocks not reachable from the CFG entry.
	UnreachableBlocks map[string]*BasicBlock
	// TotalBlocks is the total number of registered CFG blocks.
	TotalBlocks int
	// ReachableCount is the number of reachable registered blocks.
	ReachableCount int
	// UnreachableCount is the number of unreachable registered blocks.
	UnreachableCount int
	// AnalysisTime is the duration of the reachability analysis.
	AnalysisTime time.Duration
}

type ScopedCFG struct {
	Scope CFGScope
	Graph *CFG
}

type SemanticSimilarityAnalyzer struct {
	// contains filtered or unexported fields
}

type ServiceLocatorDetector struct {
	// contains filtered or unexported fields
}

type SeverityLevel string

type SimilarityAnalyzer interface {
	// ComputeSimilarity returns a similarity score between 0.0 and 1.0
	ComputeSimilarity(fragment1, fragment2 *CodeFragment) float64

	// GetName returns the name of this analyzer
	GetName() string
}

type StructuralSimilarityAnalyzer struct {
	// contains filtered or unexported fields
}

type SystemMetrics struct {
	// Overall structure
	TotalModules      int // Total number of modules
	TotalDependencies int // Total number of dependencies
	PackageCount      int // Number of packages

	// Dependency metrics
	AverageFanIn    float64 // Average number of incoming dependencies
	AverageFanOut   float64 // Average number of outgoing dependencies
	DependencyRatio float64 // Total dependencies / Total modules

	// Coupling and cohesion
	AverageInstability    float64 // System average instability
	AverageAbstractness   float64 // System average abstractness
	MainSequenceDeviation float64 // Average distance from main sequence

	// Modularity
	ModularityIndex float64 // Measure of system decomposition quality
	ComponentRatio  float64 // Ratio of strongly connected components

	// Quality indicators
	CyclicDependencies int     // Number of modules in cycles
	MaxDependencyDepth int     // Maximum dependency chain length
	SystemComplexity   float64 // Overall system complexity score

	// Refactoring
	RefactoringPriority []string // Modules needing refactoring (highest priority first)
	StableModules       []string // Low instability modules
	InstableModules     []string // High instability modules
	ZoneOfPain          []string // Stable concrete modules far from the main sequence
	ZoneOfUselessness   []string // Unstable abstract modules far from the main sequence
	MainSequence        []string // Modules close to A + I = 1
}

type TreeConverter struct {
	// contains filtered or unexported fields
}

type VarReference = coredfa.VarReference

type WeightedNeighbor struct {
	Index  int
	Weight float64
}