depgraph-core 1.5.1 → 1.8.0

package/depgraph.js

@@ -63,7 +63,9 @@ var require_constants = __commonJS({
       ".swift",
       ".kt",
       ".vue",
-      ".svelte"
+      ".svelte",
+      ".dart",
+      ".rs"
     ]);
     exports2.MAX_FILE_SIZE = 3e5;
     exports2.MAX_BFS_DEPTH = 10;
@@ -1620,6 +1622,1850 @@ var require_swift = __commonJS({
   }
 });
 
+// dist/languages/dart.js
+var require_dart = __commonJS({
+  "dist/languages/dart.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DartParser = exports2.dartEntityPatterns = void 0;
+    exports2.cleanDartComments = cleanDartComments;
+    exports2._fileStem = _fileStem;
+    exports2._makeId = _makeId;
+    exports2._splitTypes = _splitTypes;
+    exports2._findMatchingBrace = _findMatchingBrace;
+    exports2.estimateComplexity = estimateComplexity;
+    exports2.extractDart = extractDart;
+    var fs_12 = __importDefault2(require("fs"));
+    var path_1 = __importDefault2(require("path"));
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function cleanDartComments(src) {
+      const commentStringPattern = /r?"""(?:\\.|[\s\S])*?"""|r?'''(?:\\.|[\s\S])*?'''|r?"(?:\\.|[^"\\])*"|r?'(?:\\.|[^'\\])*'|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g;
+      return src.replace(commentStringPattern, (token) => {
+        if (token.startsWith("/")) {
+          const newlineCount = (token.match(/\n/g) || []).length;
+          return "\n".repeat(newlineCount);
+        }
+        return token;
+      });
+    }
+    function _fileStem(filePath) {
+      const base = path_1.default.basename(filePath);
+      const ext = path_1.default.extname(base);
+      return ext ? base.slice(0, -ext.length) : base;
+    }
+    function _makeId(...parts) {
+      return parts.filter((p) => Boolean(p && p.trim())).map((p) => p.trim().replace(/[^a-zA-Z0-9_.-]/g, "_")).join("__");
+    }
+    function _splitTypes(text) {
+      const parts = [];
+      const current = [];
+      let depth = 0;
+      for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === "<") {
+          depth++;
+          current.push(char);
+        } else if (char === ">") {
+          depth--;
+          current.push(char);
+        } else if (char === "," && depth === 0) {
+          const trimmed = current.join("").trim();
+          if (trimmed)
+            parts.push(trimmed);
+          current.length = 0;
+        } else {
+          current.push(char);
+        }
+      }
+      if (current.length > 0) {
+        const trimmed = current.join("").trim();
+        if (trimmed)
+          parts.push(trimmed);
+      }
+      return parts;
+    }
+    function _findMatchingBrace(text, startPos) {
+      let braceCount = 0;
+      let inDoubleQuote = false;
+      let inSingleQuote = false;
+      let escape = false;
+      const firstBrace = text.indexOf("{", startPos);
+      if (firstBrace === -1)
+        return text.length;
+      braceCount = 1;
+      let i = firstBrace + 1;
+      const n = text.length;
+      while (i < n) {
+        const char = text[i];
+        if (escape) {
+          escape = false;
+          i++;
+          continue;
+        }
+        if (char === "\\") {
+          escape = true;
+          i++;
+          continue;
+        }
+        if (text.slice(i, i + 3) === '"""' && !inSingleQuote) {
+          i += 3;
+          const end = text.indexOf('"""', i);
+          i = end !== -1 ? end + 3 : n;
+          continue;
+        }
+        if (text.slice(i, i + 3) === "'''" && !inDoubleQuote) {
+          i += 3;
+          const end = text.indexOf("'''", i);
+          i = end !== -1 ? end + 3 : n;
+          continue;
+        }
+        if (char === '"' && !inSingleQuote) {
+          inDoubleQuote = !inDoubleQuote;
+        } else if (char === "'" && !inDoubleQuote) {
+          inSingleQuote = !inSingleQuote;
+        } else if (!inDoubleQuote && !inSingleQuote) {
+          if (char === "{") {
+            braceCount++;
+          } else if (char === "}") {
+            braceCount--;
+            if (braceCount === 0) {
+              return i + 1;
+            }
+          }
+        }
+        i++;
+      }
+      return text.length;
+    }
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const defRegex = new RegExp(`(?:^|\\s)(?:[\\w<>\\[\\],.?]+\\s+)?${escapeRegex(name)}\\s*(?:<[^>]*>)?\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => defRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{") && !lines[startLine].includes("=>")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
+        return "low";
+      if (lines[startLine].includes("=>") && !lines[startLine].includes("{")) {
+        const arrowStmt = lines.slice(startLine, startLine + 5).join("\n");
+        const branches2 = (arrowStmt.match(/\b(if|else|switch|case|catch|&&|\|\||\?\?)\b|\?[^:]*:/g) || []).length;
+        if (branches2 <= constants_1.COMPLEXITY_THRESHOLDS.low)
+          return "low";
+        if (branches2 <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+          return "medium";
+        return "high";
+      }
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const ch of line) {
+          if (ch === "{") {
+            braceCount++;
+            started = true;
+          } else if (ch === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0)
+          break;
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|else\s+if|else|for|while|do|switch|case|catch|&&|\|\||\?\?)\b|\?[^:]*:/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.dartEntityPatterns = [
+      // class, abstract class, sealed class, mixin class, base class, interface class, final class, enum, extension type
+      {
+        regex: /^[ \t]*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+([A-Za-z_]\w*)/gm,
+        type: "class"
+      },
+      // extension MyExt on MyClass (named extension)
+      {
+        regex: /^[ \t]{0,4}extension\s+([A-Za-z_]\w+)(?:<[^>]+>)?\s+on\s+[A-Za-z_]\w*/gm,
+        type: "class"
+      },
+      // typedef
+      {
+        regex: /^[ \t]*typedef\s+(?:[\w<>,.?\s]+\s+)?([A-Za-z_]\w*)\s*(?:<[^>]+>)?\s*(?:=|\()/gm,
+        type: "type"
+      },
+      // methods, functions, getters/setters, constructors
+      {
+        regex: /^[ \t]{0,2}(?:(?:factory|static|async|external|abstract)\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+([A-Za-z_]\w*)\s*\(/gm,
+        type: "function"
+      }
+    ];
+    var DART_KEYWORDS = /* @__PURE__ */ new Set([
+      "if",
+      "for",
+      "while",
+      "switch",
+      "case",
+      "catch",
+      "return",
+      "void",
+      "dynamic",
+      "final",
+      "const",
+      "get",
+      "set",
+      "true",
+      "false",
+      "null",
+      "default",
+      "break",
+      "continue",
+      "throw",
+      "rethrow",
+      "assert",
+      "class",
+      "mixin",
+      "enum",
+      "extension",
+      "typedef",
+      "import",
+      "export",
+      "part",
+      "library",
+      "with",
+      "implements",
+      "extends",
+      "on"
+    ]);
+    var DART_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+      "String",
+      "int",
+      "double",
+      "bool",
+      "num",
+      "dynamic",
+      "Object",
+      "void",
+      "List",
+      "Map",
+      "Set",
+      "Future",
+      "Stream",
+      "Function",
+      "Record"
+    ]);
+    function extractEntities(code, filePath) {
+      const cleanCode = cleanDartComments(code);
+      const entities = [];
+      const stem = _fileStem(filePath);
+      function lineAt(offset) {
+        return cleanCode.slice(0, offset).split("\n").length;
+      }
+      const classPattern = /^[ \t]*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+(\w+)/gm;
+      let m;
+      while ((m = classPattern.exec(cleanCode)) !== null) {
+        const className = m[1];
+        if (DART_KEYWORDS.has(className))
+          continue;
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === className && e.line === line)) {
+          entities.push({
+            name: className,
+            type: "class",
+            line,
+            complexity: "low"
+          });
+        }
+      }
+      const extPattern = /^[ \t]{0,4}extension\s+(?:(\w+)(?:<[^>]+>)?\s+)?on\s+(\w+)/gm;
+      while ((m = extPattern.exec(cleanCode)) !== null) {
+        const extName = m[1] || `${stem}_anonymous_extension`;
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === extName && e.line === line)) {
+          entities.push({
+            name: extName,
+            type: "class",
+            line,
+            complexity: "low"
+          });
+        }
+      }
+      const typedefPattern = /^[ \t]*typedef\s+(?:[\w<>,.?\s]+\s+)?(\w+)\s*(?:<[^>]+>)?\s*(?:=\s*([^;]+)|\([^;]*\));/gm;
+      while ((m = typedefPattern.exec(cleanCode)) !== null) {
+        const typedefName = m[1];
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === typedefName && e.line === line)) {
+          entities.push({
+            name: typedefName,
+            type: "type",
+            line,
+            complexity: "low"
+          });
+        }
+      }
+      const varPattern = /^[ \t]{0,2}(?:late\s+)?(?:(?:final|const|var)\s+)?(?:\([^)]+\)\s+|([a-zA-Z0-9_<>,.?]+(?:\s+[a-zA-Z0-9_<>,.?]+){0,3})\s+)?(?:(\w+)|(?:\w+\s*)?\(([^)]+)\))\s*(?:=|$|;)/gm;
+      while ((m = varPattern.exec(cleanCode)) !== null) {
+        const varType = m[1];
+        const singleName = m[2];
+        const destructured = m[3];
+        if (!/^[ \t]*(?:late|final|const|var)\b/.test(m[0]) && !varType) {
+          continue;
+        }
+        if (singleName && !DART_KEYWORDS.has(singleName) && !/^[A-Z]/.test(singleName)) {
+          const line = lineAt(m.index);
+          if (!entities.some((e) => e.name === singleName && e.line === line)) {
+            entities.push({
+              name: singleName,
+              type: "variable",
+              line,
+              complexity: "low"
+            });
+          }
+        } else if (destructured) {
+          const line = lineAt(m.index);
+          const names = destructured.split(",").map((n) => n.includes(":") ? n.split(":").pop().trim() : n.trim()).filter((n) => /^[a-zA-Z_]\w*$/.test(n) && !/^[A-Z]/.test(n) && !DART_KEYWORDS.has(n));
+          for (const name of names) {
+            if (!entities.some((e) => e.name === name && e.line === line)) {
+              entities.push({
+                name,
+                type: "variable",
+                line,
+                complexity: "low"
+              });
+            }
+          }
+        }
+      }
+      const methodPattern = /^[ \t]{0,2}(?:factory\s+|static\s+|async\s+|external\s+|abstract\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+(\w+(?:\.\w+)?)\s*\(/gm;
+      while ((m = methodPattern.exec(cleanCode)) !== null) {
+        const rawName = m[1];
+        const name = rawName.split(".").pop();
+        if (DART_KEYWORDS.has(name) || /^[A-Z]/.test(name))
+          continue;
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === name && e.line === line)) {
+          entities.push({
+            name,
+            type: "function",
+            line,
+            complexity: estimateComplexity(cleanCode, name)
+          });
+        }
+      }
+      const propPattern = /^[ \t]{0,2}(?:(?:static|final|late)\s+)*(?:[\w<>\[\]?]+\s+)?(?:get|set)\s+([A-Za-z_]\w*)/gm;
+      while ((m = propPattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (DART_KEYWORDS.has(name))
+          continue;
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === name && e.line === line)) {
+          entities.push({
+            name,
+            type: "function",
+            line,
+            complexity: estimateComplexity(cleanCode, name)
+          });
+        }
+      }
+      const annotationPattern = /@(\w+)(?:\([^)]*\))?/g;
+      while ((m = annotationPattern.exec(cleanCode)) !== null) {
+        const annotationName = m[1];
+        if (annotationName.toLowerCase() === "riverpod") {
+          const annotationPos = annotationPattern.lastIndex;
+          const intervening = cleanCode.slice(annotationPos, annotationPos + 300);
+          const classM = /^[ \t]*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+(\w+)/m.exec(intervening);
+          const funcM = /^[ \t]*(?:factory\s+|static\s+|async\s+|external\s+|abstract\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+(\w+)\s*\(/m.exec(intervening);
+          let targetName = null;
+          let isClass = false;
+          if (classM && funcM) {
+            if (classM.index < funcM.index) {
+              targetName = classM[1];
+              isClass = true;
+            } else {
+              targetName = funcM[1];
+            }
+          } else if (classM) {
+            targetName = classM[1];
+            isClass = true;
+          } else if (funcM) {
+            targetName = funcM[1];
+          }
+          if (targetName) {
+            const providerName = isClass ? (targetName.length > 1 ? targetName[0].toLowerCase() + targetName.slice(1) : targetName.toLowerCase()) + "Provider" : targetName + "Provider";
+            const line = lineAt(m.index);
+            if (!entities.some((e) => e.name === providerName && e.line === line)) {
+              entities.push({
+                name: providerName,
+                type: "variable",
+                line,
+                complexity: "low"
+              });
+            }
+          }
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const cleanCode = cleanDartComments(code);
+      const imports = [];
+      const importPattern = /^[ \t]*import\s+['"]([^'"]+)['"](?:\s+(?:deferred\s+)?as\s+([A-Za-z_]\w*))?((?:\s+(?:show|hide)\s+[A-Za-z0-9_,\s]+)*)\s*;/gm;
+      let m;
+      while ((m = importPattern.exec(cleanCode)) !== null) {
+        const source = m[1];
+        const alias = m[2];
+        const clauses = m[3] || "";
+        const isLocal = !source.startsWith("package:") && !source.startsWith("dart:");
+        const names = [];
+        const showMatch = clauses.match(/\bshow\s+([^;]+)/);
+        if (showMatch) {
+          const shown = showMatch[1].split(",").map((s) => s.trim().split(/\s+/)[0]).filter(Boolean);
+          names.push(...shown);
+        } else if (alias) {
+          names.push(alias);
+        } else {
+          const baseName = path_1.default.basename(source);
+          const cleanStem = baseName.endsWith(".dart") ? baseName.slice(0, -5) : baseName;
+          names.push(cleanStem);
+        }
+        imports.push({
+          source,
+          names: [...new Set(names)],
+          isLocal
+        });
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const cleanCode = cleanDartComments(code);
+      const exports3 = [];
+      const exportPattern = /^[ \t]*export\s+['"]([^'"]+)['"](?:\s+show\s+([A-Za-z0-9_,\s]+))?\s*;/gm;
+      let m;
+      while ((m = exportPattern.exec(cleanCode)) !== null) {
+        const showClause = m[2];
+        if (showClause) {
+          const names = showClause.split(",").map((s) => s.trim().split(/\s+/)[0]).filter(Boolean);
+          exports3.push(...names);
+        } else {
+          const base = path_1.default.basename(m[1]);
+          const stem = base.endsWith(".dart") ? base.slice(0, -5) : base;
+          exports3.push(stem);
+        }
+      }
+      const typePattern = /^[ \t]*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+([A-Za-z_]\w*)/gm;
+      while ((m = typePattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (!name.startsWith("_") && !DART_KEYWORDS.has(name)) {
+          exports3.push(name);
+        }
+      }
+      const extPattern = /^[ \t]{0,4}extension\s+([A-Za-z_]\w+)(?:<[^>]+>)?\s+on\s+[A-Za-z_]\w*/gm;
+      while ((m = extPattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (name && !name.startsWith("_") && !DART_KEYWORDS.has(name)) {
+          exports3.push(name);
+        }
+      }
+      const typedefPattern = /^[ \t]*typedef\s+(?:[\w<>,.?\s]+\s+)?([A-Za-z_]\w*)\s*(?:<[^>]+>)?\s*(?:=|\()/gm;
+      while ((m = typedefPattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (!name.startsWith("_") && !DART_KEYWORDS.has(name)) {
+          exports3.push(name);
+        }
+      }
+      const funcPattern = /^[ \t]{0,2}(?:factory\s+|static\s+|async\s+|external\s+|abstract\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+([A-Za-z_]\w*)\s*\(/gm;
+      while ((m = funcPattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (!name.startsWith("_") && !/^[A-Z]/.test(name) && !DART_KEYWORDS.has(name)) {
+          exports3.push(name);
+        }
+      }
+      const varPattern = /^[ \t]{0,2}(?:(?:final|const|var)\s+)(?:[a-zA-Z0-9_<>,.?]+\s+)?([A-Za-z_]\w*)\s*=/gm;
+      while ((m = varPattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (!name.startsWith("_") && !DART_KEYWORDS.has(name)) {
+          exports3.push(name);
+        }
+      }
+      return [...new Set(exports3)];
+    }
+    exports2.DartParser = {
+      lang: "dart",
+      extensions: [".dart"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.dartEntityPatterns
+    };
+    (0, registry_1.registerParser)(exports2.DartParser);
+    function extractDart(fileInput) {
+      let src;
+      let filePathStr;
+      if (typeof fileInput === "string") {
+        filePathStr = fileInput;
+        const isPath = (fileInput.endsWith(".dart") || fileInput.includes("/") || fileInput.includes("\\")) && !fileInput.includes("\n");
+        if (isPath) {
+          try {
+            src = fs_12.default.readFileSync(fileInput, "utf-8");
+          } catch (err) {
+            return { nodes: [], edges: [], error: `cannot read ${fileInput}` };
+          }
+        } else {
+          src = fileInput;
+          filePathStr = "main.dart";
+        }
+      } else {
+        filePathStr = fileInput.path;
+        try {
+          src = fileInput.readText ? fileInput.readText() : fs_12.default.readFileSync(fileInput.path, "utf-8");
+        } catch (err) {
+          return { nodes: [], edges: [], error: `cannot read ${fileInput.path}` };
+        }
+      }
+      const srcClean = cleanDartComments(src);
+      function lineAt(offset) {
+        return srcClean.slice(0, offset).split("\n").length;
+      }
+      let stem = _fileStem(filePathStr);
+      let fileNid = _makeId(filePathStr);
+      let isPart = false;
+      const partOfMatch = /^\s*part\s+of\s+['"]([^'"]+)['"]/m.exec(srcClean);
+      if (partOfMatch) {
+        const parentRef = partOfMatch[1];
+        if (parentRef.endsWith(".dart")) {
+          try {
+            const parentPath = path_1.default.resolve(path_1.default.dirname(filePathStr), parentRef);
+            if (fs_12.default.existsSync(parentPath)) {
+              stem = _fileStem(parentPath);
+              fileNid = _makeId(parentPath);
+              isPart = true;
+            }
+          } catch {
+          }
+        }
+      }
+      const nodes = [];
+      if (!isPart) {
+        nodes.push({
+          id: fileNid,
+          label: path_1.default.basename(filePathStr),
+          file_type: "code",
+          source_file: filePathStr,
+          source_location: null
+        });
+      }
+      const edges = [];
+      const defined = /* @__PURE__ */ new Set();
+      function addNode(nid, label, ftype = "code", sourceFile = filePathStr, line = null) {
+        if (!defined.has(nid)) {
+          nodes.push({
+            id: nid,
+            label,
+            file_type: ftype,
+            source_file: sourceFile,
+            source_location: line ? `L${line}` : null
+          });
+          defined.add(nid);
+        }
+      }
+      function addEdge(srcId, tgtId, relation, weight = 1, context, line) {
+        const edge = {
+          source: srcId,
+          target: tgtId,
+          relation,
+          confidence: "EXTRACTED",
+          confidence_score: 1,
+          source_file: filePathStr,
+          source_location: line ? `L${line}` : null,
+          weight
+        };
+        if (context)
+          edge.context = context;
+        edges.push(edge);
+      }
+      const classPattern = /^\s*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+(\w+)/gm;
+      let m;
+      while ((m = classPattern.exec(srcClean)) !== null) {
+        const className = m[1];
+        const classLine = lineAt(m.index + m[0].indexOf(className));
+        const classNid = _makeId(stem, className);
+        addNode(classNid, className, "code", filePathStr, classLine);
+        addEdge(fileNid, classNid, "defines", 1, void 0, classLine);
+        const startIdx = classPattern.lastIndex;
+        let rest = srcClean.slice(startIdx, startIdx + 500);
+        if (rest.trimStart().startsWith("<")) {
+          const offset = rest.indexOf("<");
+          let depth = 1;
+          let i = offset + 1;
+          while (i < rest.length && depth > 0) {
+            if (rest[i] === "<")
+              depth++;
+            else if (rest[i] === ">")
+              depth--;
+            i++;
+          }
+          rest = rest.slice(i);
+        }
+        if (rest.trimStart().startsWith("(")) {
+          const offset = rest.indexOf("(");
+          let depth = 1;
+          let i = offset + 1;
+          while (i < rest.length && depth > 0) {
+            if (rest[i] === "(")
+              depth++;
+            else if (rest[i] === ")")
+              depth--;
+            i++;
+          }
+          rest = rest.slice(i);
+        }
+        let headerEnd = rest.indexOf("{");
+        if (headerEnd === -1)
+          headerEnd = rest.indexOf(";");
+        if (headerEnd === -1)
+          headerEnd = rest.length;
+        let header = rest.slice(0, headerEnd);
+        let baseClass = null;
+        let generics = null;
+        let mixinsList = [];
+        let interfacesList = [];
+        const extendsM = /^\s*(?:extends|on)\s+([a-zA-Z0-9_.]+)/.exec(header);
+        if (extendsM) {
+          baseClass = extendsM[1];
+          const restHeader = header.slice(extendsM.index + extendsM[0].length);
+          if (restHeader.trimStart().startsWith("<")) {
+            const startBracket = restHeader.indexOf("<");
+            let depth = 1;
+            let i = startBracket + 1;
+            while (i < restHeader.length && depth > 0) {
+              if (restHeader[i] === "<")
+                depth++;
+              else if (restHeader[i] === ">") {
+                depth--;
+                if (depth === 0) {
+                  generics = restHeader.slice(startBracket + 1, i);
+                  break;
+                }
+              }
+              i++;
+            }
+            header = generics !== null ? restHeader.slice(i + 1) : restHeader;
+          } else {
+            header = restHeader;
+          }
+        }
+        const withM = /^\s*with\s+/.exec(header);
+        if (withM) {
+          const restHeader = header.slice(withM.index + withM[0].length);
+          const implIdx = restHeader.indexOf("implements");
+          let mixinsStr = "";
+          if (implIdx !== -1) {
+            mixinsStr = restHeader.slice(0, implIdx);
+            header = restHeader.slice(implIdx);
+          } else {
+            mixinsStr = restHeader;
+            header = "";
+          }
+          mixinsList = _splitTypes(mixinsStr);
+        }
+        const implM = /^\s*implements\s+/.exec(header);
+        if (implM) {
+          interfacesList = _splitTypes(header.slice(implM.index + implM[0].length));
+        }
+        if (baseClass) {
+          const baseNid = _makeId(baseClass);
+          addNode(baseNid, baseClass, "code", null);
+          addEdge(classNid, baseNid, "inherits", 1, void 0, classLine);
+          if (generics) {
+            for (const gen of _splitTypes(generics)) {
+              const genClean = gen.split("<")[0].trim();
+              if (!DART_PRIMITIVE_TYPES.has(genClean)) {
+                const genNid = _makeId(genClean);
+                addNode(genNid, genClean, "code", null);
+                addEdge(classNid, genNid, "references", 1, void 0, classLine);
+              }
+            }
+          }
+        }
+        for (const mixin of mixinsList) {
+          const mixinClean = mixin.split("<")[0].trim();
+          const mixinNid = _makeId(mixinClean);
+          addNode(mixinNid, mixinClean, "code", null);
+          addEdge(classNid, mixinNid, "mixes_in", 1, void 0, classLine);
+        }
+        for (const iface of interfacesList) {
+          const ifaceClean = iface.split("<")[0].trim();
+          const ifaceNid = _makeId(ifaceClean);
+          addNode(ifaceNid, ifaceClean, "code", null);
+          addEdge(classNid, ifaceNid, "implements", 1, void 0, classLine);
+        }
+        const declStart = m.index;
+        const bracePos = srcClean.indexOf("{", declStart);
+        const semiPos = srcClean.indexOf(";", declStart);
+        let hasBody = bracePos !== -1;
+        if (hasBody && semiPos !== -1 && semiPos < bracePos) {
+          hasBody = false;
+        }
+        if (hasBody) {
+          const endPos = _findMatchingBrace(srcClean, declStart);
+          const classBody = srcClean.slice(bracePos, endPos);
+          const onEventRegex = /\bon<(\w+)>\s*\(/g;
+          let em;
+          while ((em = onEventRegex.exec(classBody)) !== null) {
+            const eventName = em[1];
+            const eventNid = _makeId(eventName);
+            addNode(eventNid, eventName, "code", null);
+            addEdge(classNid, eventNid, "calls", 1, "bloc_event", lineAt(bracePos + em.index));
+          }
+          const emitRegex = /\b(?:emit|yield)\s*\(?\s*(?:const\s+)?([A-Z]\w*)\b/g;
+          let sm;
+          while ((sm = emitRegex.exec(classBody)) !== null) {
+            const stateName = sm[1];
+            if (!DART_PRIMITIVE_TYPES.has(stateName)) {
+              const stateNid = _makeId(stateName);
+              addNode(stateNid, stateName, "code", null);
+              addEdge(classNid, stateNid, "calls", 1, "emit_state", lineAt(bracePos + sm.index));
+            }
+          }
+          const addEventRegex = /\b(?:(?:\w*[Bb]loc\w*|context\.read<\w+>\(\)|widget)\.)?add\(\s*(?:const\s+)?([A-Z]\w*)\b/g;
+          let am;
+          while ((am = addEventRegex.exec(classBody)) !== null) {
+            const eventName = am[1];
+            if (!DART_PRIMITIVE_TYPES.has(eventName)) {
+              const eventNid = _makeId(eventName);
+              addNode(eventNid, eventName, "code", null);
+              addEdge(classNid, eventNid, "calls", 1, "bloc_add_event", lineAt(bracePos + am.index));
+            }
+          }
+          const refRegex = /\bref\.(?:watch|read|listen)\s*\(\s*(\w+)\b/g;
+          let rm;
+          while ((rm = refRegex.exec(classBody)) !== null) {
+            const providerName = rm[1];
+            const providerNid = _makeId(providerName);
+            addNode(providerNid, providerName, "code", null);
+            addEdge(classNid, providerNid, "references", 1, "riverpod_reference", lineAt(bracePos + rm.index));
+          }
+          const widgetBlocRegex = /\bBloc(?:Builder|Listener|Consumer|Provider|Selector)\s*<\s*([a-zA-Z0-9_]+)\b/g;
+          let bm;
+          while ((bm = widgetBlocRegex.exec(classBody)) !== null) {
+            const blocName = bm[1];
+            if (!DART_PRIMITIVE_TYPES.has(blocName)) {
+              const blocNid = _makeId(blocName);
+              addNode(blocNid, blocName, "code", null);
+              addEdge(classNid, blocNid, "references", 1, "bloc_widget_binding", lineAt(bracePos + bm.index));
+            }
+          }
+          const contextLookupRegex = /\b(?:read|watch|select|of)\s*<([a-zA-Z0-9_]+)>/g;
+          let lm;
+          while ((lm = contextLookupRegex.exec(classBody)) !== null) {
+            const blocName = lm[1];
+            if (!DART_PRIMITIVE_TYPES.has(blocName)) {
+              const blocNid = _makeId(blocName);
+              addNode(blocNid, blocName, "code", null);
+              addEdge(classNid, blocNid, "references", 1, "bloc_lookup", lineAt(bracePos + lm.index));
+            }
+          }
+        }
+      }
+      const annotationPattern = /@(\w+)(?:\([^)]*\))?/g;
+      let anMatch;
+      while ((anMatch = annotationPattern.exec(srcClean)) !== null) {
+        const annotationName = anMatch[1];
+        if (["override", "deprecated", "required", "protected", "mustCallSuper"].includes(annotationName)) {
+          continue;
+        }
+        const annotationPos = annotationPattern.lastIndex;
+        const intervening = srcClean.slice(annotationPos, annotationPos + 300);
+        const classM = /^\s*(?:(?:abstract|sealed|base|interface|final|mixin)\s+)*(?:class|mixin|enum|extension\s+type)\s+(\w+)/m.exec(intervening);
+        const funcM = /^\s*(?:factory\s+|static\s+|async\s+|external\s+|abstract\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+(\w+)\s*\(/m.exec(intervening);
+        let targetNid = null;
+        let targetName = null;
+        let targetType = null;
+        if (classM && funcM) {
+          if (classM.index < funcM.index) {
+            targetName = classM[1];
+            targetType = "class";
+            targetNid = _makeId(stem, targetName);
+          } else {
+            targetName = funcM[1];
+            targetType = "function";
+            targetNid = _makeId(stem, targetName);
+          }
+        } else if (classM) {
+          targetName = classM[1];
+          targetType = "class";
+          targetNid = _makeId(stem, targetName);
+        } else if (funcM) {
+          targetName = funcM[1];
+          targetType = "function";
+          targetNid = _makeId(stem, targetName);
+        }
+        if (targetNid && targetName) {
+          const minOffset = Math.min(classM ? classM.index : 300, funcM ? funcM.index : 300);
+          const actualIntervening = intervening.slice(0, minOffset);
+          if (!actualIntervening.includes(";") && !actualIntervening.includes("}") && !actualIntervening.includes("{")) {
+            const annotationLine = lineAt(anMatch.index);
+            const annotationNid = _makeId("annotation", annotationName.toLowerCase());
+            addNode(annotationNid, `@${annotationName}`, "concept", null);
+            addEdge(targetNid, annotationNid, "configures", 1, void 0, annotationLine);
+            if (annotationName.toLowerCase() === "riverpod") {
+              const providerName = targetType === "class" ? (targetName.length > 1 ? targetName[0].toLowerCase() + targetName.slice(1) : targetName.toLowerCase()) + "Provider" : targetName + "Provider";
+              const providerNid = _makeId(providerName);
+              addNode(providerNid, providerName, "concept", filePathStr, annotationLine);
+              addEdge(targetNid, providerNid, "defines", 1, "riverpod_provider", annotationLine);
+            }
+          }
+        }
+      }
+      const typedefPattern = /^\s*typedef\s+(\w+)\s*(?:<[^>]+>)?\s*=\s*([^;]+);/gm;
+      while ((m = typedefPattern.exec(srcClean)) !== null) {
+        const typedefName = m[1];
+        const typedefLine = lineAt(m.index);
+        const targetType = m[2].split("<")[0].split(".").pop().trim();
+        if (!DART_PRIMITIVE_TYPES.has(targetType)) {
+          const typedefNid = _makeId(stem, typedefName);
+          addNode(typedefNid, typedefName, "code", filePathStr, typedefLine);
+          addEdge(fileNid, typedefNid, "defines", 1, void 0, typedefLine);
+          const targetNid = _makeId(targetType);
+          addNode(targetNid, targetType, "code", null);
+          addEdge(typedefNid, targetNid, "references", 1, "typedef", typedefLine);
+        }
+      }
+      const extPattern = /^\s{0,4}extension\s+(?:(\w+)(?:<[^>]+>)?\s+)?on\s+(\w+)/gm;
+      while ((m = extPattern.exec(srcClean)) !== null) {
+        const extName = m[1] || `${stem}_anonymous_extension`;
+        const targetClass = m[2];
+        const extLine = lineAt(m.index);
+        const extNid = _makeId(stem, extName);
+        const label = m[1] || `Extension on ${targetClass}`;
+        addNode(extNid, label, "code", filePathStr, extLine);
+        addEdge(fileNid, extNid, "defines", 1, void 0, extLine);
+        const targetNid = _makeId(targetClass);
+        addNode(targetNid, targetClass, "code", null);
+        addEdge(extNid, targetNid, "extends", 1, void 0, extLine);
+      }
+      const varPattern = /^\s{0,2}(?:late\s+)?(?:(?:final|const|var)\s+)?(?:\([^)]+\)\s+|([a-zA-Z0-9_<>,.?]+(?:\s+[a-zA-Z0-9_<>,.?]+){0,3})\s+)?(?:(\w+)|(?:\w+\s*)?\(([^)]+)\))\s*(?:=|$|;)/gm;
+      while ((m = varPattern.exec(srcClean)) !== null) {
+        const varType = m[1];
+        const singleName = m[2];
+        const destructuredNames = m[3];
+        if (!/^\s*(?:late|final|const|var)\b/.test(m[0]) && !varType) {
+          continue;
+        }
+        if (singleName && !["if", "for", "while", "switch", "catch", "return"].includes(singleName)) {
+          const varLine = lineAt(m.index);
+          const varNid = _makeId(stem, singleName);
+          addNode(varNid, singleName, "code", filePathStr, varLine);
+          addEdge(fileNid, varNid, "defines", 1, void 0, varLine);
+          if (varType) {
+            const cleanType = varType.split("<")[0].split(".").pop().trim();
+            if (!DART_PRIMITIVE_TYPES.has(cleanType)) {
+              const typeNid = _makeId(cleanType);
+              addNode(typeNid, cleanType, "code", null);
+              addEdge(fileNid, typeNid, "references", 1, "variable_type", varLine);
+            }
+          }
+        } else if (destructuredNames) {
+          const destructureLine = lineAt(m.index);
+          const names = destructuredNames.split(",").map((n) => n.includes(":") ? n.split(":").pop().trim() : n.trim()).filter((n) => /^[a-zA-Z_]\w*$/.test(n) && !/^[A-Z]/.test(n) && !["if", "for", "while", "switch", "catch", "return"].includes(n));
+          for (const name of names) {
+            const varNid = _makeId(stem, name);
+            addNode(varNid, name, "code", filePathStr, destructureLine);
+            addEdge(fileNid, varNid, "defines", 1, void 0, destructureLine);
+          }
+        }
+      }
+      const methodPattern = /^\s{0,2}(?:factory\s+|static\s+|async\s+|external\s+|abstract\s+)?(?:\([^)]+\)|[a-zA-Z0-9_<>,.?]+)(?:\s+[a-zA-Z0-9_<>,.?]+){0,3}\s+(\w+(?:\.\w+)?)\s*\(/gm;
+      while ((m = methodPattern.exec(srcClean)) !== null) {
+        const rawName = m[1];
+        const name = rawName.split(".").pop();
+        if (["if", "for", "while", "switch", "catch", "return", "void", "dynamic", "final", "const", "get", "set"].includes(name)) {
+          continue;
+        }
+        if (/^[A-Z]/.test(name))
+          continue;
+        const methodLine = lineAt(m.index);
+        const nid = _makeId(stem, name);
+        addNode(nid, name, "code", filePathStr, methodLine);
+        addEdge(fileNid, nid, "defines", 1, void 0, methodLine);
+        const startIdx = m.index;
+        const bracePos = srcClean.indexOf("{", startIdx);
+        const semiPos = srcClean.indexOf(";", startIdx);
+        const arrowPos = srcClean.indexOf("=>", startIdx);
+        let hasBody = bracePos !== -1;
+        if (hasBody && semiPos !== -1 && semiPos < bracePos)
+          hasBody = false;
+        if (hasBody && arrowPos !== -1 && arrowPos < bracePos)
+          hasBody = false;
+        if (hasBody) {
+          const endPos = _findMatchingBrace(srcClean, startIdx);
+          const funcBody = srcClean.slice(bracePos, endPos);
+          const refRegex = /\bref\.(?:watch|read|listen)\s*\(\s*(\w+)\b/g;
+          let rm;
+          while ((rm = refRegex.exec(funcBody)) !== null) {
+            const providerName = rm[1];
+            const providerNid = _makeId(providerName);
+            addNode(providerNid, providerName, "code", null);
+            addEdge(nid, providerNid, "references", 1, "riverpod_reference", lineAt(bracePos + rm.index));
+          }
+          const addEventRegex = /\b(?:(?:\w*[Bb]loc\w*|context\.read<\w+>\(\)|widget)\.)?add\(\s*(?:const\s+)?([A-Z]\w*)\b/g;
+          let am;
+          while ((am = addEventRegex.exec(funcBody)) !== null) {
+            const eventName = am[1];
+            if (!DART_PRIMITIVE_TYPES.has(eventName)) {
+              const eventNid = _makeId(eventName);
+              addNode(eventNid, eventName, "code", null);
+              addEdge(nid, eventNid, "calls", 1, "bloc_add_event", lineAt(bracePos + am.index));
+            }
+          }
+          const contextLookupRegex = /\b(?:read|watch|select|of)\s*<([a-zA-Z0-9_]+)>/g;
+          let lm;
+          while ((lm = contextLookupRegex.exec(funcBody)) !== null) {
+            const blocName = lm[1];
+            if (!DART_PRIMITIVE_TYPES.has(blocName)) {
+              const blocNid = _makeId(blocName);
+              addNode(blocNid, blocName, "code", null);
+              addEdge(nid, blocNid, "references", 1, "bloc_lookup", lineAt(bracePos + lm.index));
+            }
+          }
+          const routePathRegex = /\b(?:go|push|goNamed|pushNamed|replace|replaceNamed)\s*\(\s*(?:context\s*,\s*)?['"]([a-zA-Z0-9_/?=&%-]+)['"]/g;
+          let nm;
+          while ((nm = routePathRegex.exec(funcBody)) !== null) {
+            const routePath = nm[1];
+            const routeNid = _makeId("route", routePath.replace(/[/=&#?-]/g, "_"));
+            addNode(routeNid, `Route ${routePath}`, "concept", null);
+            addEdge(nid, routeNid, "navigates", 1, "route_path", lineAt(bracePos + nm.index));
+          }
+          const routeConstRegex = /\b(?:go|push|goNamed|pushNamed|replace|replaceNamed)\s*\(\s*(?:context\s*,\s*)?([A-Z][a-zA-Z0-9_]*\.[a-zA-Z0-9_]+)/g;
+          let cm;
+          while ((cm = routeConstRegex.exec(funcBody)) !== null) {
+            const routeConst = cm[1];
+            const routeNid = _makeId("route", routeConst.replace(/\./g, "_"));
+            addNode(routeNid, routeConst, "concept", null);
+            addEdge(nid, routeNid, "navigates", 1, "route_const", lineAt(bracePos + cm.index));
+          }
+          const routeObjRegex = /\b(?:push|replace)\s*\(\s*(?:context\s*,\s*)?.*?\b([A-Z]\w*(?:Route|Screen|Page))\b/g;
+          let om;
+          while ((om = routeObjRegex.exec(funcBody)) !== null) {
+            const routeClass = om[1];
+            const routeNid = _makeId(routeClass);
+            addNode(routeNid, routeClass, "code", null);
+            addEdge(nid, routeNid, "navigates", 1, "route_object", lineAt(bracePos + om.index));
+          }
+        }
+      }
+      const importPattern = /^\s*import\s+['"]([^'"]+)['"]/gm;
+      while ((m = importPattern.exec(srcClean)) !== null) {
+        const pkg = m[1];
+        const tgtNid = _makeId(pkg);
+        addNode(tgtNid, pkg, "code", null);
+        addEdge(fileNid, tgtNid, "imports", 1, void 0, lineAt(m.index));
+      }
+      const exportPattern = /^\s*export\s+['"]([^'"]+)['"]/gm;
+      while ((m = exportPattern.exec(srcClean)) !== null) {
+        const pkg = m[1];
+        const tgtNid = _makeId(pkg);
+        addNode(tgtNid, pkg, "code", null);
+        addEdge(fileNid, tgtNid, "exports", 1, void 0, lineAt(m.index));
+      }
+      const genericCallPattern = /\b\w+<([a-zA-Z0-9_.]+(?:<[a-zA-Z0-9_.,\s<>]+>)?)\s*>\s*\(/g;
+      while ((m = genericCallPattern.exec(srcClean)) !== null) {
+        const typeName = m[1].split(".").pop().trim();
+        const cleanName = typeName.split("<")[0].trim();
+        if (!DART_PRIMITIVE_TYPES.has(cleanName)) {
+          const targetNid = _makeId(cleanName);
+          addNode(targetNid, cleanName, "code", null);
+          addEdge(fileNid, targetNid, "references", 1, "type_lookup", lineAt(m.index));
+        }
+      }
+      return { nodes, edges };
+    }
+  }
+});
+
+// dist/languages/rust.js
+var require_rust = __commonJS({
+  "dist/languages/rust.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RustParser = exports2.rustEntityPatterns = exports2.RUST_TRAIT_METHOD_BLOCKLIST = void 0;
+    exports2._fileStem = _fileStem;
+    exports2._makeId = _makeId;
+    exports2.cleanRustComments = cleanRustComments;
+    exports2._splitBalanced = _splitBalanced;
+    exports2._findMatchingBrace = _findMatchingBrace;
+    exports2._rustCollectTypeRefs = _rustCollectTypeRefs;
+    exports2.estimateComplexity = estimateComplexity;
+    exports2.extractRust = extractRust;
+    var fs_12 = __importDefault2(require("fs"));
+    var path_1 = __importDefault2(require("path"));
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    exports2.RUST_TRAIT_METHOD_BLOCKLIST = /* @__PURE__ */ new Set([
+      "new",
+      "default",
+      "parse",
+      "from_str",
+      "now",
+      "clone",
+      "into",
+      "from",
+      "to_string",
+      "to_owned",
+      "len",
+      "is_empty",
+      "iter",
+      "next",
+      "build",
+      "start",
+      "run",
+      "init",
+      "app",
+      "get",
+      "set",
+      "push",
+      "pop",
+      "insert",
+      "remove",
+      "contains",
+      "collect",
+      "map",
+      "filter",
+      "unwrap",
+      "expect",
+      "ok",
+      "err",
+      "some",
+      "none",
+      "send",
+      "recv",
+      "lock",
+      "read",
+      "write"
+    ]);
+    var RUST_PRIMITIVES = /* @__PURE__ */ new Set([
+      "bool",
+      "char",
+      "str",
+      "i8",
+      "i16",
+      "i32",
+      "i64",
+      "i128",
+      "isize",
+      "u8",
+      "u16",
+      "u32",
+      "u64",
+      "u128",
+      "usize",
+      "f32",
+      "f64",
+      "()",
+      "!"
+    ]);
+    var RUST_KEYWORDS = /* @__PURE__ */ new Set([
+      "as",
+      "async",
+      "await",
+      "break",
+      "const",
+      "continue",
+      "crate",
+      "dyn",
+      "else",
+      "enum",
+      "extern",
+      "false",
+      "fn",
+      "for",
+      "if",
+      "impl",
+      "in",
+      "let",
+      "loop",
+      "match",
+      "mod",
+      "move",
+      "mut",
+      "pub",
+      "ref",
+      "return",
+      "self",
+      "Self",
+      "static",
+      "struct",
+      "super",
+      "trait",
+      "true",
+      "type",
+      "unsafe",
+      "use",
+      "where",
+      "while"
+    ]);
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function _fileStem(filePath) {
+      const base = path_1.default.basename(filePath);
+      const ext = path_1.default.extname(base);
+      return ext ? base.slice(0, -ext.length) : base;
+    }
+    function _makeId(...parts) {
+      return parts.filter((p) => Boolean(p && p.trim())).map((p) => p.trim().replace(/[^a-zA-Z0-9_.-]/g, "_")).join("__");
+    }
+    function cleanRustComments(src) {
+      const commentStringPattern = /b?r(#*)".*?"\1|b?"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])'|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g;
+      return src.replace(commentStringPattern, (token) => {
+        if (token.startsWith("/")) {
+          const newlineCount = (token.match(/\n/g) || []).length;
+          return "\n".repeat(newlineCount);
+        }
+        return token;
+      });
+    }
+    function _splitBalanced(text, delim = ",") {
+      const parts = [];
+      const current = [];
+      let depthAngle = 0;
+      let depthParen = 0;
+      let depthBracket = 0;
+      for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "<")
+          depthAngle++;
+        else if (ch === ">")
+          depthAngle--;
+        else if (ch === "(")
+          depthParen++;
+        else if (ch === ")")
+          depthParen--;
+        else if (ch === "[")
+          depthBracket++;
+        else if (ch === "]")
+          depthBracket--;
+        else if (ch === delim && depthAngle === 0 && depthParen === 0 && depthBracket === 0) {
+          const trimmed = current.join("").trim();
+          if (trimmed)
+            parts.push(trimmed);
+          current.length = 0;
+          continue;
+        }
+        current.push(ch);
+      }
+      if (current.length > 0) {
+        const trimmed = current.join("").trim();
+        if (trimmed)
+          parts.push(trimmed);
+      }
+      return parts;
+    }
+    function _findMatchingBrace(text, startPos) {
+      let braceCount = 0;
+      let inDoubleQuote = false;
+      let escape = false;
+      const firstBrace = text.indexOf("{", startPos);
+      if (firstBrace === -1)
+        return text.length;
+      braceCount = 1;
+      let i = firstBrace + 1;
+      const n = text.length;
+      while (i < n) {
+        const char = text[i];
+        if (escape) {
+          escape = false;
+          i++;
+          continue;
+        }
+        if (char === "\\") {
+          escape = true;
+          i++;
+          continue;
+        }
+        if (char === '"') {
+          inDoubleQuote = !inDoubleQuote;
+        } else if (!inDoubleQuote) {
+          if (char === "{") {
+            braceCount++;
+          } else if (char === "}") {
+            braceCount--;
+            if (braceCount === 0) {
+              return i + 1;
+            }
+          }
+        }
+        i++;
+      }
+      return text.length;
+    }
+    function _rustCollectTypeRefs(typeStr, generic, out) {
+      if (!typeStr)
+        return;
+      const raw = typeStr.trim();
+      if (!raw)
+        return;
+      let clean = raw.replace(/&(?:\s*'[a-zA-Z_]\w*)?\s*(?:mut\s+)?/g, "").trim();
+      clean = clean.replace(/^\*(?:const|mut)\s+/g, "").trim();
+      if (clean.startsWith("[") && clean.endsWith("]")) {
+        const inner = clean.slice(1, -1).split(";")[0].trim();
+        _rustCollectTypeRefs(inner, generic, out);
+        return;
+      }
+      if (clean.startsWith("(") && clean.endsWith(")")) {
+        const inner = clean.slice(1, -1).trim();
+        if (inner) {
+          for (const part of _splitBalanced(inner)) {
+            _rustCollectTypeRefs(part, generic, out);
+          }
+        }
+        return;
+      }
+      if (clean.includes("+") && !clean.includes("<")) {
+        for (const part of clean.split("+")) {
+          _rustCollectTypeRefs(part.trim(), generic, out);
+        }
+        return;
+      }
+      if (clean.startsWith("dyn ")) {
+        clean = clean.slice(4).trim();
+      }
+      const angleIdx = clean.indexOf("<");
+      if (angleIdx !== -1 && clean.endsWith(">")) {
+        const baseType = clean.slice(0, angleIdx).trim();
+        const lastBaseSegment = baseType.split("::").pop().trim();
+        if (!RUST_PRIMITIVES.has(lastBaseSegment) && lastBaseSegment) {
+          out.push([lastBaseSegment, generic ? "generic_arg" : "type"]);
+        }
+        const argsText = clean.slice(angleIdx + 1, -1).trim();
+        const args2 = _splitBalanced(argsText);
+        for (const arg of args2) {
+          _rustCollectTypeRefs(arg, true, out);
+        }
+        return;
+      }
+      const lastSegment = clean.split("::").pop().trim();
+      if (!RUST_PRIMITIVES.has(lastSegment) && /^[a-zA-Z_]\w*$/.test(lastSegment)) {
+        out.push([lastSegment, generic ? "generic_arg" : "type"]);
+      }
+    }
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const defRegex = new RegExp(`(?:^|\\s)fn\\s+${escapeRegex(name)}\\s*(?:<[^>]*>)?\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => defRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
+        return "low";
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const ch of line) {
+          if (ch === "{") {
+            braceCount++;
+            started = true;
+          } else if (ch === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0)
+          break;
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|else\s+if|else|for|while|loop|match)\b|\?|(&&|\|\|)/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.rustEntityPatterns = [
+      // Functions: free functions, methods, async fn, const fn, unsafe fn
+      {
+        regex: /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:(?:async|const|unsafe|extern(?:\s+"[^"]*")?)\s+)*fn\s+([A-Za-z_]\w*)/gm,
+        type: "function"
+      },
+      // Structs
+      {
+        regex: /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)/gm,
+        type: "class"
+      },
+      // Enums
+      {
+        regex: /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)/gm,
+        type: "class"
+      },
+      // Traits
+      {
+        regex: /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:unsafe\s+)?trait\s+([A-Za-z_]\w*)/gm,
+        type: "interface"
+      },
+      // Impl blocks: impl Type or impl Trait for Type
+      {
+        regex: /^[ \t]*impl(?:\s*<[^>]*>)?\s+(?:[A-Za-z_]\w*(?:\s*<[^>]*>)?\s+for\s+)?([A-Za-z_]\w*)/gm,
+        type: "class"
+      },
+      // Type aliases
+      {
+        regex: /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?type\s+([A-Za-z_]\w*)/gm,
+        type: "type"
+      }
+    ];
+    function extractEntities(code, _filePath) {
+      const cleanCode = cleanRustComments(code);
+      const entities = [];
+      function lineAt(offset) {
+        return cleanCode.slice(0, offset).split("\n").length;
+      }
+      const itemPattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:(struct|enum)|(?:unsafe\s+)?(trait))\s+([A-Za-z_]\w*)/gm;
+      let m;
+      while ((m = itemPattern.exec(cleanCode)) !== null) {
+        const isStructOrEnum = Boolean(m[1]);
+        const name = m[3];
+        if (RUST_KEYWORDS.has(name))
+          continue;
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === name && e.line === line)) {
+          entities.push({
+            name,
+            type: isStructOrEnum ? "class" : "interface",
+            line,
+            complexity: "low"
+          });
+        }
+      }
+      const typeAliasPattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?type\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*=/gm;
+      while ((m = typeAliasPattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (RUST_KEYWORDS.has(name))
+          continue;
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === name && e.line === line)) {
+          entities.push({
+            name,
+            type: "type",
+            line,
+            complexity: "low"
+          });
+        }
+      }
+      const fnPattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:(?:async|const|unsafe|extern(?:\s+"[^"]*")?)\s+)*fn\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(/gm;
+      while ((m = fnPattern.exec(cleanCode)) !== null) {
+        const name = m[1];
+        if (RUST_KEYWORDS.has(name))
+          continue;
+        const line = lineAt(m.index);
+        if (!entities.some((e) => e.name === name && e.line === line)) {
+          entities.push({
+            name,
+            type: "function",
+            line,
+            complexity: estimateComplexity(cleanCode, name)
+          });
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const cleanCode = cleanRustComments(code);
+      const imports = [];
+      const usePattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?use\s+([^;]+);/gm;
+      let m;
+      while ((m = usePattern.exec(cleanCode)) !== null) {
+        const raw = m[1].trim();
+        const isLocal = raw.startsWith("crate::") || raw.startsWith("super::") || raw.startsWith("self::");
+        if (raw.includes("{")) {
+          const braceStart = raw.indexOf("{");
+          const basePrefix = raw.slice(0, braceStart).replace(/::$/, "").trim();
+          const inner = raw.slice(braceStart + 1, raw.lastIndexOf("}")).trim();
+          const items = inner.split(",").map((s) => s.trim()).filter(Boolean);
+          const names = [];
+          for (const item of items) {
+            if (item === "self") {
+              const baseName = basePrefix.split("::").pop();
+              names.push(baseName);
+            } else if (item.includes(" as ")) {
+              const alias = item.split(" as ")[1].trim();
+              names.push(alias);
+            } else {
+              names.push(item.split("::").pop().trim());
+            }
+          }
+          imports.push({
+            source: basePrefix,
+            names: [...new Set(names)],
+            isLocal
+          });
+        } else {
+          let source = "";
+          let name = "";
+          if (raw.includes(" as ")) {
+            const parts = raw.split(" as ");
+            source = parts[0].trim();
+            name = parts[1].trim();
+          } else {
+            source = raw.trim();
+            const segments = raw.split("::");
+            name = segments[segments.length - 1].trim();
+          }
+          imports.push({
+            source,
+            names: [name],
+            isLocal
+          });
+        }
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const cleanCode = cleanRustComments(code);
+      const exports3 = [];
+      const itemPattern = /^[ \t]*pub(?:\([^)]*\))?\s+(?:(?:unsafe\s+)?(?:trait)|struct|enum|type)\s+([A-Za-z_]\w*)/gm;
+      let m;
+      while ((m = itemPattern.exec(cleanCode)) !== null) {
+        exports3.push(m[1]);
+      }
+      const fnPattern = /^[ \t]*pub(?:\([^)]*\))?\s+(?:(?:async|const|unsafe|extern(?:\s+"[^"]*")?)\s+)*fn\s+([A-Za-z_]\w*)/gm;
+      while ((m = fnPattern.exec(cleanCode)) !== null) {
+        exports3.push(m[1]);
+      }
+      const constPattern = /^[ \t]*pub(?:\([^)]*\))?\s+(?:const|static)\s+([A-Za-z_]\w*)/gm;
+      while ((m = constPattern.exec(cleanCode)) !== null) {
+        exports3.push(m[1]);
+      }
+      const usePattern = /^[ \t]*pub(?:\([^)]*\))?\s+use\s+([^;]+);/gm;
+      while ((m = usePattern.exec(cleanCode)) !== null) {
+        const raw = m[1].trim();
+        if (raw.includes("{")) {
+          const inner = raw.slice(raw.indexOf("{") + 1, raw.lastIndexOf("}")).trim();
+          const items = inner.split(",").map((s) => s.trim().split(/\s+as\s+/).pop()).filter(Boolean);
+          exports3.push(...items);
+        } else {
+          const last = raw.split(" as ").pop().split("::").pop().trim();
+          if (last && last !== "*")
+            exports3.push(last);
+        }
+      }
+      return [...new Set(exports3)];
+    }
+    exports2.RustParser = {
+      lang: "rust",
+      extensions: [".rs"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.rustEntityPatterns
+    };
+    (0, registry_1.registerParser)(exports2.RustParser);
+    function extractRust(fileInput) {
+      let source;
+      let strPath;
+      if (typeof fileInput === "string") {
+        strPath = fileInput;
+        const isPath = (fileInput.endsWith(".rs") || fileInput.includes("/") || fileInput.includes("\\")) && !fileInput.includes("\n");
+        if (isPath) {
+          try {
+            source = fs_12.default.readFileSync(fileInput, "utf-8");
+          } catch (err) {
+            return { nodes: [], edges: [], raw_calls: [], error: `cannot read ${fileInput}` };
+          }
+        } else {
+          source = fileInput;
+          strPath = "main.rs";
+        }
+      } else {
+        strPath = fileInput.path;
+        try {
+          source = fileInput.readText ? fileInput.readText() : fs_12.default.readFileSync(fileInput.path, "utf-8");
+        } catch (err) {
+          return { nodes: [], edges: [], raw_calls: [], error: `cannot read ${fileInput.path}` };
+        }
+      }
+      const cleanSource = cleanRustComments(source);
+      const stem = _fileStem(strPath);
+      function lineAt(offset) {
+        return cleanSource.slice(0, offset).split("\n").length;
+      }
+      const nodes = [];
+      const edges = [];
+      const rawCalls = [];
+      const seenIds = /* @__PURE__ */ new Set();
+      function addNode(nid, label, line) {
+        if (!seenIds.has(nid)) {
+          seenIds.add(nid);
+          nodes.push({
+            id: nid,
+            label,
+            file_type: "code",
+            source_file: strPath,
+            source_location: `L${line}`
+          });
+        }
+      }
+      function addEdge(src, tgt, relation, line, confidence = "EXTRACTED", weight = 1, context) {
+        const edge = {
+          source: src,
+          target: tgt,
+          relation,
+          confidence,
+          source_file: strPath,
+          source_location: `L${line}`,
+          weight
+        };
+        if (context)
+          edge.context = context;
+        edges.push(edge);
+      }
+      const fileNid = _makeId(strPath);
+      addNode(fileNid, path_1.default.basename(strPath), 1);
+      function ensureNamedNode(name, line) {
+        const nidInFile = _makeId(stem, name);
+        if (seenIds.has(nidInFile)) {
+          return nidInFile;
+        }
+        const nidGlobal = _makeId(name);
+        if (!seenIds.has(nidGlobal)) {
+          seenIds.add(nidGlobal);
+          nodes.push({
+            id: nidGlobal,
+            label: name,
+            file_type: "code",
+            source_file: "",
+            source_location: "",
+            origin_file: strPath
+          });
+        }
+        return nidGlobal;
+      }
+      function emitParamReturnRefs(paramsText, returnText, funcNid, line) {
+        if (paramsText) {
+          for (const p of _splitBalanced(paramsText)) {
+            if (p === "&self" || p === "&mut self" || p === "self" || p === "mut self")
+              continue;
+            const colonIdx = p.indexOf(":");
+            if (colonIdx !== -1) {
+              const typePart = p.slice(colonIdx + 1).trim();
+              const refs = [];
+              _rustCollectTypeRefs(typePart, false, refs);
+              for (const [refName, role] of refs) {
+                const ctx = role === "generic_arg" ? "generic_arg" : "parameter_type";
+                const tgt = ensureNamedNode(refName, line);
+                if (tgt !== funcNid) {
+                  addEdge(funcNid, tgt, "references", line, "EXTRACTED", 1, ctx);
+                }
+              }
+            }
+          }
+        }
+        if (returnText) {
+          const refs = [];
+          _rustCollectTypeRefs(returnText, false, refs);
+          for (const [refName, role] of refs) {
+            const ctx = role === "generic_arg" ? "generic_arg" : "return_type";
+            const tgt = ensureNamedNode(refName, line);
+            if (tgt !== funcNid) {
+              addEdge(funcNid, tgt, "references", line, "EXTRACTED", 1, ctx);
+            }
+          }
+        }
+      }
+      const functionBodies = [];
+      const itemPattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:(struct|enum)|(?:unsafe\s+)?(trait)|(impl))\b/gm;
+      let m;
+      while ((m = itemPattern.exec(cleanSource)) !== null) {
+        const itemStart = m.index;
+        const kind = m[1] || m[2] || m[3];
+        const headerEnd = cleanSource.indexOf("{", itemStart);
+        const semiEnd = cleanSource.indexOf(";", itemStart);
+        if (kind === "struct") {
+          const structM = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)(?:<[^>]*>)?(?:\s*\(([^)]*)\)|\s*\{)?/m.exec(cleanSource.slice(itemStart, itemStart + 300));
+          if (structM) {
+            const structName = structM[1];
+            const line = lineAt(itemStart);
+            const structNid = _makeId(stem, structName);
+            addNode(structNid, structName, line);
+            addEdge(fileNid, structNid, "contains", line);
+            const tupleFields = structM[2];
+            if (tupleFields !== void 0) {
+              for (const field of _splitBalanced(tupleFields)) {
+                const cleanField = field.replace(/^pub(?:\([^)]*\))?\s+/, "").trim();
+                const refs = [];
+                _rustCollectTypeRefs(cleanField, false, refs);
+                for (const [refName, role] of refs) {
+                  const ctx = role === "generic_arg" ? "generic_arg" : "field";
+                  const tgt = ensureNamedNode(refName, line);
+                  if (tgt !== structNid) {
+                    addEdge(structNid, tgt, "references", line, "EXTRACTED", 1, ctx);
+                  }
+                }
+              }
+            } else if (headerEnd !== -1 && (semiEnd === -1 || headerEnd < semiEnd)) {
+              const bodyEnd = _findMatchingBrace(cleanSource, itemStart);
+              const body = cleanSource.slice(headerEnd + 1, bodyEnd - 1);
+              for (const rawField of _splitBalanced(body, ",")) {
+                const field = rawField.trim();
+                if (!field)
+                  continue;
+                const colonIdx = field.indexOf(":");
+                if (colonIdx !== -1) {
+                  const fType = field.slice(colonIdx + 1).trim();
+                  const fLine = lineAt(headerEnd);
+                  const refs = [];
+                  _rustCollectTypeRefs(fType, false, refs);
+                  for (const [refName, role] of refs) {
+                    const ctx = role === "generic_arg" ? "generic_arg" : "field";
+                    const tgt = ensureNamedNode(refName, fLine);
+                    if (tgt !== structNid) {
+                      addEdge(structNid, tgt, "references", fLine, "EXTRACTED", 1, ctx);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        } else if (kind === "enum") {
+          const enumM = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)/m.exec(cleanSource.slice(itemStart, itemStart + 200));
+          if (enumM && headerEnd !== -1) {
+            const enumName = enumM[1];
+            const line = lineAt(itemStart);
+            const enumNid = _makeId(stem, enumName);
+            addNode(enumNid, enumName, line);
+            addEdge(fileNid, enumNid, "contains", line);
+            const bodyEnd = _findMatchingBrace(cleanSource, itemStart);
+            const body = cleanSource.slice(headerEnd + 1, bodyEnd - 1);
+            const variantPattern = /([A-Za-z_]\w*)(?:\s*\(([^)]*)\)|\s*\{([^}]*)\})?/g;
+            let vm;
+            while ((vm = variantPattern.exec(body)) !== null) {
+              const vLine = lineAt(headerEnd + vm.index);
+              const tupleTypes = vm[2];
+              const structFields = vm[3];
+              if (tupleTypes) {
+                for (const t of _splitBalanced(tupleTypes)) {
+                  const refs = [];
+                  _rustCollectTypeRefs(t.trim(), false, refs);
+                  for (const [refName, role] of refs) {
+                    const ctx = role === "generic_arg" ? "generic_arg" : "field";
+                    const tgt = ensureNamedNode(refName, vLine);
+                    if (tgt !== enumNid) {
+                      addEdge(enumNid, tgt, "references", vLine, "EXTRACTED", 1, ctx);
+                    }
+                  }
+                }
+              } else if (structFields) {
+                for (const rawField of _splitBalanced(structFields, ",")) {
+                  const field = rawField.trim();
+                  if (!field)
+                    continue;
+                  const colonIdx = field.indexOf(":");
+                  if (colonIdx !== -1) {
+                    const fType = field.slice(colonIdx + 1).trim();
+                    const refs = [];
+                    _rustCollectTypeRefs(fType, false, refs);
+                    for (const [refName, role] of refs) {
+                      const ctx = role === "generic_arg" ? "generic_arg" : "field";
+                      const tgt = ensureNamedNode(refName, vLine);
+                      if (tgt !== enumNid) {
+                        addEdge(enumNid, tgt, "references", vLine, "EXTRACTED", 1, ctx);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        } else if (kind === "trait") {
+          const traitM = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:unsafe\s+)?trait\s+([A-Za-z_]\w*)(?:<[^>]*>)?(?:\s*:\s*([^{]+))?/m.exec(cleanSource.slice(itemStart, itemStart + 300));
+          if (traitM && headerEnd !== -1) {
+            const traitName = traitM[1];
+            const line = lineAt(itemStart);
+            const traitNid = _makeId(stem, traitName);
+            addNode(traitNid, traitName, line);
+            addEdge(fileNid, traitNid, "contains", line);
+            const boundsStr = traitM[2];
+            if (boundsStr) {
+              const bounds = boundsStr.split("+").map((s) => s.trim()).filter(Boolean);
+              for (let idx = 0; idx < bounds.length; idx++) {
+                const b = bounds[idx];
+                const refs = [];
+                _rustCollectTypeRefs(b, false, refs);
+                for (let rIdx = 0; rIdx < refs.length; rIdx++) {
+                  const [refName] = refs[rIdx];
+                  const tgt = ensureNamedNode(refName, line);
+                  if (tgt === traitNid)
+                    continue;
+                  const rel = idx === 0 && rIdx === 0 ? "inherits" : "references";
+                  addEdge(traitNid, tgt, rel, line, "EXTRACTED", 1, rel === "references" ? "generic_arg" : void 0);
+                }
+              }
+            }
+            const bodyEnd = _findMatchingBrace(cleanSource, itemStart);
+            const body = cleanSource.slice(headerEnd + 1, bodyEnd - 1);
+            const traitMethodPattern = /^[ \t]*(?:(?:async|const|unsafe|extern(?:\s+"[^"]*")?)\s+)*fn\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(([^)]*)\)(?:\s*->\s*([^{;]+))?\s*([{;])/gm;
+            let tmm;
+            while ((tmm = traitMethodPattern.exec(body)) !== null) {
+              const methodName = tmm[1];
+              const mLine = lineAt(headerEnd + tmm.index);
+              const methodNid = _makeId(traitNid, methodName);
+              addNode(methodNid, `.${methodName}()`, mLine);
+              addEdge(traitNid, methodNid, "method", mLine);
+              emitParamReturnRefs(tmm[2], tmm[3], methodNid, mLine);
+              if (tmm[4] === "{") {
+                const mBodyEnd = _findMatchingBrace(body, tmm.index);
+                const mBody = body.slice(tmm.index + tmm[0].length - 1, mBodyEnd);
+                functionBodies.push([methodNid, mBody, headerEnd + tmm.index + tmm[0].length - 1]);
+              }
+            }
+          }
+        } else if (kind === "impl") {
+          const implHeader = cleanSource.slice(itemStart, headerEnd).trim();
+          const implM = /^[ \t]*impl(?:\s*<[^>]*>)?\s+(?:([A-Za-z_]\w*(?:\s*<[^>]*>)?)\s+for\s+)?([A-Za-z_]\w*(?:\s*<[^>]*>)?)/m.exec(implHeader);
+          if (implM && headerEnd !== -1) {
+            const traitPart = implM[1];
+            const typePart = implM[2];
+            const typeName = typePart.split("<")[0].split("::").pop().trim();
+            const line = lineAt(itemStart);
+            const implNid = _makeId(stem, typeName);
+            addNode(implNid, typeName, line);
+            if (traitPart) {
+              const traitRefs = [];
+              _rustCollectTypeRefs(traitPart, false, traitRefs);
+              for (let idx = 0; idx < traitRefs.length; idx++) {
+                const [refName] = traitRefs[idx];
+                const tgt = ensureNamedNode(refName, line);
+                if (tgt !== implNid) {
+                  if (idx === 0) {
+                    addEdge(implNid, tgt, "implements", line);
+                  } else {
+                    addEdge(implNid, tgt, "references", line, "EXTRACTED", 1, "generic_arg");
+                  }
+                }
+              }
+            }
+            const bodyEnd = _findMatchingBrace(cleanSource, itemStart);
+            const body = cleanSource.slice(headerEnd + 1, bodyEnd - 1);
+            const implMethodPattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:(?:async|const|unsafe|extern(?:\s+"[^"]*")?)\s+)*fn\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(([^)]*)\)(?:\s*->\s*([^{]+))?\s*\{/gm;
+            let imm;
+            while ((imm = implMethodPattern.exec(body)) !== null) {
+              const methodName = imm[1];
+              const mLine = lineAt(headerEnd + imm.index);
+              const methodNid = _makeId(implNid, methodName);
+              addNode(methodNid, `.${methodName}()`, mLine);
+              addEdge(implNid, methodNid, "method", mLine);
+              emitParamReturnRefs(imm[2], imm[3], methodNid, mLine);
+              const mBodyEnd = _findMatchingBrace(body, imm.index);
+              const mBody = body.slice(imm.index + imm[0].length - 1, mBodyEnd);
+              functionBodies.push([methodNid, mBody, headerEnd + imm.index + imm[0].length - 1]);
+            }
+          }
+        }
+      }
+      const freeFnPattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?(?:(?:async|const|unsafe|extern(?:\s+"[^"]*")?)\s+)*fn\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(([^)]*)\)(?:\s*->\s*([^{]+))?\s*\{/gm;
+      while ((m = freeFnPattern.exec(cleanSource)) !== null) {
+        const funcName = m[1];
+        const funcLine = lineAt(m.index);
+        const funcNid = _makeId(stem, funcName);
+        if (!seenIds.has(funcNid)) {
+          addNode(funcNid, `${funcName}()`, funcLine);
+          addEdge(fileNid, funcNid, "contains", funcLine);
+          emitParamReturnRefs(m[2], m[3], funcNid, funcLine);
+          const mBodyEnd = _findMatchingBrace(cleanSource, m.index);
+          const mBody = cleanSource.slice(m.index + m[0].length - 1, mBodyEnd);
+          functionBodies.push([funcNid, mBody, m.index + m[0].length - 1]);
+        }
+      }
+      const usePattern = /^[ \t]*(?:pub(?:\([^)]*\))?\s+)?use\s+([^;]+);/gm;
+      while ((m = usePattern.exec(cleanSource)) !== null) {
+        const raw = m[1].trim();
+        const line = lineAt(m.index);
+        if (raw.includes("{")) {
+          const basePrefix = raw.slice(0, raw.indexOf("{")).replace(/::$/, "").trim();
+          const moduleName = basePrefix.split("::").pop().trim();
+          if (moduleName) {
+            const tgtNid = _makeId(moduleName);
+            addEdge(fileNid, tgtNid, "imports_from", line, "EXTRACTED", 1, "import");
+          }
+        } else {
+          const clean = raw.split(" as ")[0].trim().replace(/::\*$/, "").replace(/::$/, "");
+          const moduleName = clean.split("::").pop().trim();
+          if (moduleName) {
+            const tgtNid = _makeId(moduleName);
+            addEdge(fileNid, tgtNid, "imports_from", line, "EXTRACTED", 1, "import");
+          }
+        }
+      }
+      const labelToNid = {};
+      for (const n of nodes) {
+        const raw = n.label;
+        const normalised = raw.replace(/\(\)$/, "").replace(/^\./, "");
+        labelToNid[normalised] = n.id;
+      }
+      const seenCallPairs = /* @__PURE__ */ new Set();
+      for (const [callerNid, bodyCode, bodyOffset] of functionBodies) {
+        const callPattern = /([A-Za-z_]\w*)(?:::([A-Za-z_]\w*))?\s*\(|\.([A-Za-z_]\w*)\s*\(/g;
+        let cm;
+        while ((cm = callPattern.exec(bodyCode)) !== null) {
+          const isMemberCall = Boolean(cm[3]);
+          const isScopedCall = Boolean(cm[2]);
+          const calleeName = cm[3] || cm[2] || cm[1];
+          if (!calleeName || RUST_KEYWORDS.has(calleeName))
+            continue;
+          const callLine = lineAt(bodyOffset + cm.index);
+          const tgtNid = labelToNid[calleeName];
+          if (tgtNid && tgtNid !== callerNid) {
+            const pairKey = `${callerNid}->${tgtNid}`;
+            if (!seenCallPairs.has(pairKey)) {
+              seenCallPairs.add(pairKey);
+              edges.push({
+                source: callerNid,
+                target: tgtNid,
+                relation: "calls",
+                confidence: "EXTRACTED",
+                source_file: strPath,
+                source_location: `L${callLine}`,
+                weight: 1,
+                context: "call"
+              });
+            }
+          } else if (!isScopedCall && !exports2.RUST_TRAIT_METHOD_BLOCKLIST.has(calleeName.toLowerCase())) {
+            rawCalls.push({
+              caller_nid: callerNid,
+              callee: calleeName,
+              is_member_call: isMemberCall,
+              source_file: strPath,
+              source_location: `L${callLine}`
+            });
+          }
+        }
+      }
+      const validIds = seenIds;
+      const cleanEdges = edges.filter((e) => validIds.has(e.source) && (validIds.has(e.target) || e.relation === "imports_from" || e.relation === "imports"));
+      return { nodes, edges: cleanEdges, raw_calls: rawCalls };
+    }
+  }
+});
+
 // dist/stages/collector.js
 var require_collector = __commonJS({
   "dist/stages/collector.js"(exports2) {
@@ -1819,7 +3665,15 @@ var require_graph = __commonJS({
     }
     function resolvePath(fromFile, importSource, allFiles) {
       const fromDir = path_1.default.dirname(fromFile);
-      const base = path_1.default.join(fromDir, importSource);
+      let normalizedSource = importSource;
+      if (normalizedSource.startsWith("crate::")) {
+        normalizedSource = normalizedSource.slice(7).replace(/::/g, "/");
+      } else if (normalizedSource.startsWith("super::")) {
+        normalizedSource = "../" + normalizedSource.slice(7).replace(/::/g, "/");
+      } else if (normalizedSource.startsWith("self::")) {
+        normalizedSource = "./" + normalizedSource.slice(6).replace(/::/g, "/");
+      }
+      const base = path_1.default.join(fromDir, normalizedSource);
       const candidates = [
         base,
         `${base}.ts`,
@@ -1827,7 +3681,9 @@ var require_graph = __commonJS({
         `${base}.js`,
         `${base}.jsx`,
         `${base}/index.ts`,
-        `${base}/index.js`
+        `${base}/index.js`,
+        `${base}.dart`,
+        `${base}.rs`
       ];
       for (const candidate of candidates) {
         const normalized = candidate.replace(/\\/g, "/");
@@ -1835,6 +3691,23 @@ var require_graph = __commonJS({
         if (found)
           return found.filePath;
       }
+      const parentBase = path_1.default.dirname(base);
+      if (parentBase && parentBase !== base) {
+        const parentCandidates = [
+          `${parentBase}.rs`,
+          `${parentBase}.ts`,
+          `${parentBase}.tsx`,
+          `${parentBase}.js`,
+          `${parentBase}.jsx`,
+          `${parentBase}.dart`
+        ];
+        for (const candidate of parentCandidates) {
+          const normalized = candidate.replace(/\\/g, "/");
+          const found = allFiles.find((f) => f.filePath.replace(/\\/g, "/") === normalized);
+          if (found)
+            return found.filePath;
+        }
+      }
       return null;
     }
   }
@@ -2270,6 +4143,8 @@ require_kotlin();
 require_php();
 require_ruby();
 require_swift();
+require_dart();
+require_rust();
 var fs_1 = __importDefault(require("fs"));
 var collector_1 = require_collector();
 var parser_1 = require_parser();
@@ -2298,7 +4173,7 @@ function getFlag(flag) {
 }
 function printHelp() {
   console.log(`
-${bold("DepGraph")} ${dim("v1.5.1")}
+${bold("DepGraph")} ${dim("v1.8.0")}
 ${dim("Dependency mapping \xB7 Impact simulation \xB7 Developer intelligence")}
 
 ${bold("USAGE")}
@@ -2347,7 +4222,7 @@ ${bold("GIT EXAMPLES")}
 function printBanner() {
   console.log(`
 ${bold("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501")}
-${bold("  DepGraph")}  ${dim("v1.0.0")}
+${bold("  DepGraph")}  ${dim("v1.8.0")}
 ${bold("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501")}
 `);
 }