cgraphx 1.4.3 → 2.0.0

package/dist/resolution/stdlib-blocklist.d.ts

@@ -1,53 +0,0 @@
-/**
- * Standard-library reference fast-path.
- *
- * Why this exists: Java projects (and other JVM languages) generate huge
- * volumes of references to JDK types — `List`, `Date`, `Integer`, `Object`,
- * `Override`, `@Autowired`, etc. — that have no definition in the project's
- * own source. `resolveOne`'s existing fast-path
- *
- *     !hasAnyPossibleMatch(name) && !matchesAnyImport(ref) && ...
- *
- * does NOT short-circuit these, because almost every Java file declares
- * `import java.util.List;` (or similar), so `matchesAnyImport` returns true
- * and the reference walks the full resolver chain (frameworks → import →
- * name-match → fuzzy), scoring zero candidates and failing — but burning
- * CPU on every single ref. On a 10k-file Java monorepo this is tens of
- * thousands of refs (one report: List×21k, Date×9k, Integer×8k, Object×8k,
- * Override×8k, Map×7.5k — ~80k refs of pure waste).
- *
- * This module is consulted BEFORE `matchesAnyImport` so the JDK short-circuit
- * isn't defeated by ubiquitous `import java.util.*` lines. It is conservative:
- * if the project happens to declare its own same-named symbol (e.g. a custom
- * `List` class), `resolveOne` checks `hasAnyPossibleMatch` separately and
- * skips the stdlib fast-path, so legitimate project symbols still resolve.
- *
- * Scope is intentionally narrow: only the most common JDK names that show up
- * in unresolved_refs by the tens of thousands. Adding a name here is safe
- * (worst case = a project's own same-named symbol stays unresolved, but the
- * `hasAnyPossibleMatch` guard prevents that).
- */
-/**
- * Test whether a reference name points at a known standard-library symbol.
- *
- * Handles three shapes:
- *   - Simple name:           `List`                 → check simple-name set
- *   - Fully-qualified:       `java.util.List`       → check prefix + tail
- *   - Receiver-qualified:    `CollectionUtils.isNotEmpty`, `this.foo`, `obj.method`
- *                            → check the receiver (and the tail for FQN)
- *
- * Receiver-qualified calls like `foo.bar()` are NOT stdlib by this function —
- * `foo` is a value, not a type, and we cannot tell statically whether `foo`'s
- * type is a JDK class. Resolution should still try. (Receiver `super` / `this`
- * are explicitly NOT stdlib.)
- */
-export declare function isStdlibReference(name: string): boolean;
-/**
- * Test export (for unit tests + future library author expansion). Returns the
- * underlying sets — do NOT mutate.
- */
-export declare function __debugGetSets(): {
-    simple: ReadonlySet<string>;
-    qualified: readonly string[];
-};
-//# sourceMappingURL=stdlib-blocklist.d.ts.map

package/dist/resolution/stdlib-blocklist.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdlib-blocklist.d.ts","sourceRoot":"","sources":["../../src/resolution/stdlib-blocklist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAyEH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAkBvD;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI;IAChC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5B,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B,CAEA"}

package/dist/resolution/stdlib-blocklist.js

@@ -1,143 +0,0 @@
-"use strict";
-/**
- * Standard-library reference fast-path.
- *
- * Why this exists: Java projects (and other JVM languages) generate huge
- * volumes of references to JDK types — `List`, `Date`, `Integer`, `Object`,
- * `Override`, `@Autowired`, etc. — that have no definition in the project's
- * own source. `resolveOne`'s existing fast-path
- *
- *     !hasAnyPossibleMatch(name) && !matchesAnyImport(ref) && ...
- *
- * does NOT short-circuit these, because almost every Java file declares
- * `import java.util.List;` (or similar), so `matchesAnyImport` returns true
- * and the reference walks the full resolver chain (frameworks → import →
- * name-match → fuzzy), scoring zero candidates and failing — but burning
- * CPU on every single ref. On a 10k-file Java monorepo this is tens of
- * thousands of refs (one report: List×21k, Date×9k, Integer×8k, Object×8k,
- * Override×8k, Map×7.5k — ~80k refs of pure waste).
- *
- * This module is consulted BEFORE `matchesAnyImport` so the JDK short-circuit
- * isn't defeated by ubiquitous `import java.util.*` lines. It is conservative:
- * if the project happens to declare its own same-named symbol (e.g. a custom
- * `List` class), `resolveOne` checks `hasAnyPossibleMatch` separately and
- * skips the stdlib fast-path, so legitimate project symbols still resolve.
- *
- * Scope is intentionally narrow: only the most common JDK names that show up
- * in unresolved_refs by the tens of thousands. Adding a name here is safe
- * (worst case = a project's own same-named symbol stays unresolved, but the
- * `hasAnyPossibleMatch` guard prevents that).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStdlibReference = isStdlibReference;
-exports.__debugGetSets = __debugGetSets;
-/**
- * Simple names (un-qualified) of common JDK types, annotations, and exceptions
- * that are virtually never defined in user code. Drawn from java.lang,
- * java.util, java.io, java.time, java.util.function, java.util.concurrent,
- * and the most common annotation packages.
- *
- * Kept as a `Set` for O(1) lookup; the resolver hot loop calls
- * `isStdlibReference` once per ref.
- */
-const JVM_STDLIB_SIMPLE_NAMES = new Set([
-    // java.lang — primitives + wrappers + core
-    'String', 'Integer', 'Long', 'Double', 'Float', 'Boolean', 'Byte', 'Short', 'Character', 'Number', 'Void', 'Object', 'Class', 'Math',
-    'Comparable', 'CharSequence', 'Iterable', 'Runnable', 'Thread', 'Throwable', 'Exception', 'RuntimeException', 'Error',
-    'NullPointerException', 'ClassCastException', 'IllegalArgumentException', 'IllegalStateException', 'IndexOutOfBoundsException',
-    'ArrayIndexOutOfBoundsException', 'ArithmeticException', 'UnsupportedOperationException', 'IOException',
-    'StringBuilder', 'StringBuffer',
-    // java.util — collections + date/time legacy + misc
-    'List', 'Map', 'Set', 'Collection', 'Iterator', 'ListIterator', 'Iterable',
-    'ArrayList', 'LinkedList', 'HashMap', 'LinkedHashMap', 'TreeMap', 'HashSet', 'LinkedHashSet', 'TreeSet',
-    'Dictionary', 'Hashtable', 'Vector', 'Stack', 'Queue', 'Deque', 'ArrayDeque', 'PriorityQueue',
-    'Collections', 'Arrays', 'Objects', 'Comparator', 'NaturalOrder', 'Optional',
-    'Date', 'Calendar', 'GregorianCalendar', 'TimeZone', 'SimpleTimeZone',
-    'UUID', 'Random', 'Scanner', 'Formatter', 'Locale',
-    'Properties', 'PropertyResourceBundle',
-    // java.util.function / .stream / .concurrent
-    'Function', 'BiFunction', 'Consumer', 'BiConsumer', 'Predicate', 'BiPredicate', 'Supplier',
-    'UnaryOperator', 'BinaryOperator',
-    'Stream', 'IntStream', 'LongStream', 'DoubleStream', 'Collectors',
-    'Callable', 'Future', 'CompletableFuture', 'Executor', 'ExecutorService', 'ThreadPoolExecutor', 'ScheduledExecutorService',
-    // java.io / java.nio
-    'File', 'Path', 'Paths', 'Files', 'InputStream', 'OutputStream', 'Reader', 'Writer',
-    'BufferedReader', 'BufferedWriter', 'InputStreamReader', 'OutputStreamWriter',
-    'FileInputStream', 'FileOutputStream', 'FileReader', 'FileWriter',
-    'PrintWriter', 'PrintStream', 'ByteArrayInputStream', 'ByteArrayOutputStream',
-    'Serializable', 'Externalizable', 'ObjectInputStream', 'ObjectOutputStream',
-    'IOException', 'FileNotFoundException', 'EOFException',
-    // java.time (Java 8+)
-    'LocalDate', 'LocalTime', 'LocalDateTime', 'Instant', 'Duration', 'Period', 'ZonedDateTime', 'OffsetDateTime', 'ZoneId', 'DateTimeFormatter',
-    // java.math
-    'BigDecimal', 'BigInteger',
-    // java.text
-    'SimpleDateFormat', 'DecimalFormat', 'NumberFormat', 'ParseException',
-    // Common annotations (java.lang + java.lang.annotation + javax/jakarta)
-    'Override', 'Deprecated', 'SuppressWarnings', 'FunctionalInterface', 'SafeVarargs',
-    'Retention', 'Target', 'Documented', 'Inherited', 'Repeatable',
-    // javax/jakarta + Spring (commonly unresolved in service code)
-    'Resource', 'Autowired', 'Service', 'Component', 'Controller', 'RestController', 'Repository', 'Configuration', 'Bean', 'Qualifier', 'Value', 'RequestMapping', 'GetMapping', 'PostMapping',
-    'Inject', 'Named', 'Singleton',
-    'Transactional',
-    'JsonProperty', 'JsonIgnore', 'JsonFormat',
-    'Slf4j', 'Log',
-]);
-/**
- * Fully-qualified JDK package prefixes. A reference whose qualified name starts
- * with one of these (e.g. `java.util.List`, `com.google.common.collect.ImmutableList`)
- * is treated as stdlib. We DO NOT include third-party libs by default (Guava,
- * Commons-Lang, Jackson, etc.) because projects sometimes re-export or shim
- * them; JDK packages are safe because the JDK itself is never project code.
- */
-const JVM_STDLIB_QUALIFIED_PREFIXES = [
-    'java.',
-    'javax.',
-    'jakarta.',
-    'sun.',
-    'com.sun.',
-    'org.w3c.dom.',
-    'org.xml.sax.',
-    'org.ietf.jgss.',
-];
-/**
- * Test whether a reference name points at a known standard-library symbol.
- *
- * Handles three shapes:
- *   - Simple name:           `List`                 → check simple-name set
- *   - Fully-qualified:       `java.util.List`       → check prefix + tail
- *   - Receiver-qualified:    `CollectionUtils.isNotEmpty`, `this.foo`, `obj.method`
- *                            → check the receiver (and the tail for FQN)
- *
- * Receiver-qualified calls like `foo.bar()` are NOT stdlib by this function —
- * `foo` is a value, not a type, and we cannot tell statically whether `foo`'s
- * type is a JDK class. Resolution should still try. (Receiver `super` / `this`
- * are explicitly NOT stdlib.)
- */
-function isStdlibReference(name) {
-    if (!name)
-        return false;
-    // Fast path: simple name in the set
-    if (JVM_STDLIB_SIMPLE_NAMES.has(name))
-        return true;
-    // Fully-qualified JDK reference (`java.util.List`, `java.io.Serializable`)
-    for (const prefix of JVM_STDLIB_QUALIFIED_PREFIXES) {
-        if (name.startsWith(prefix))
-            return true;
-    }
-    // Dotted name — could be `pkg.Type` (FQN without java prefix, e.g. Guava)
-    // or `receiver.member` (call site). Only the FQN shape is stdlib-relevant;
-    // we already covered `java.*` above, so the only remaining dotted stdlib
-    // shape is `LocalDate.now()` style — but `LocalDate` itself is already in
-    // JVM_STDLIB_SIMPLE_NAMES and the resolver will use that path. So we don't
-    // need to split here.
-    return false;
-}
-/**
- * Test export (for unit tests + future library author expansion). Returns the
- * underlying sets — do NOT mutate.
- */
-function __debugGetSets() {
-    return { simple: JVM_STDLIB_SIMPLE_NAMES, qualified: JVM_STDLIB_QUALIFIED_PREFIXES };
-}
-//# sourceMappingURL=stdlib-blocklist.js.map

package/dist/resolution/stdlib-blocklist.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdlib-blocklist.js","sourceRoot":"","sources":["../../src/resolution/stdlib-blocklist.ts"],"names":[],"mappings":"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"}

package/dist/resolution/strip-comments.d.ts

@@ -1,27 +0,0 @@
-/**
- * Per-language comment stripper for framework route extractors.
- *
- * Replaces comment characters and string-literal contents that hide
- * routing-shaped text with spaces (NOT removal) so that source offsets
- * are preserved. This means `match.index` from a regex run on the
- * stripped output still maps to the same line in the original source.
- *
- * Example:
- *   Input:  "x = 1  # path('/fake/', V)\n real = 2"
- *   Output: "x = 1                       \n real = 2"
- *
- * Why strip strings/docstrings as well as comments? Python module/class
- * docstrings are a common source of false positives — they often contain
- * `path('/example/', View)` examples in usage docs. We treat triple-quoted
- * strings the same as comments. Single-line strings stay intact (a `#`
- * inside a Python string is NOT a comment).
- *
- * Scope: this is a pragmatic, regex-supporting helper, not a full parser.
- * It does NOT try to detect JS regex literals, Python f-string expressions,
- * or shell-style heredocs. Those edge cases are not load-bearing for the
- * `path(...)`, `Route::get(...)`, `app.get(...)` style patterns that
- * framework extractors scan for.
- */
-export type CommentLang = 'python' | 'javascript' | 'typescript' | 'php' | 'ruby' | 'java' | 'csharp' | 'swift' | 'go' | 'rust' | 'c' | 'cpp';
-export declare function stripCommentsForRegex(content: string, lang: CommentLang): string;
-//# sourceMappingURL=strip-comments.d.ts.map

package/dist/resolution/strip-comments.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strip-comments.d.ts","sourceRoot":"","sources":["../../src/resolution/strip-comments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,WAAW,GACnB,QAAQ,GACR,YAAY,GACZ,YAAY,GACZ,KAAK,GACL,MAAM,GACN,MAAM,GACN,QAAQ,GACR,OAAO,GACP,IAAI,GACJ,MAAM,GACN,GAAG,GACH,KAAK,CAAC;AAEV,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAuBhF"}

package/dist/resolution/strip-comments.js

@@ -1,443 +0,0 @@
-"use strict";
-/**
- * Per-language comment stripper for framework route extractors.
- *
- * Replaces comment characters and string-literal contents that hide
- * routing-shaped text with spaces (NOT removal) so that source offsets
- * are preserved. This means `match.index` from a regex run on the
- * stripped output still maps to the same line in the original source.
- *
- * Example:
- *   Input:  "x = 1  # path('/fake/', V)\n real = 2"
- *   Output: "x = 1                       \n real = 2"
- *
- * Why strip strings/docstrings as well as comments? Python module/class
- * docstrings are a common source of false positives — they often contain
- * `path('/example/', View)` examples in usage docs. We treat triple-quoted
- * strings the same as comments. Single-line strings stay intact (a `#`
- * inside a Python string is NOT a comment).
- *
- * Scope: this is a pragmatic, regex-supporting helper, not a full parser.
- * It does NOT try to detect JS regex literals, Python f-string expressions,
- * or shell-style heredocs. Those edge cases are not load-bearing for the
- * `path(...)`, `Route::get(...)`, `app.get(...)` style patterns that
- * framework extractors scan for.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripCommentsForRegex = stripCommentsForRegex;
-function stripCommentsForRegex(content, lang) {
-    switch (lang) {
-        case 'python':
-            return stripPython(content);
-        case 'ruby':
-            return stripRuby(content);
-        case 'rust':
-            return stripRust(content);
-        case 'php':
-            return stripPhp(content);
-        case 'go':
-            return stripGo(content);
-        case 'javascript':
-        case 'typescript':
-        case 'java':
-        case 'csharp':
-        case 'swift':
-        case 'c':
-        case 'cpp':
-            return stripCStyle(content, /* allowSingleQuoteStrings */ lang === 'javascript' || lang === 'typescript');
-        default:
-            return content;
-    }
-}
-/**
- * Replace every char in a slice with spaces, but keep newlines so line
- * numbers computed downstream remain valid.
- */
-function blankRange(buf, start, end, src) {
-    for (let i = start; i < end; i++) {
-        buf[i] = src[i] === '\n' ? '\n' : ' ';
-    }
-}
-// ---------- Python ----------
-function stripPython(src) {
-    const out = src.split('');
-    let i = 0;
-    const n = src.length;
-    while (i < n) {
-        const c = src[i];
-        const c2 = src[i + 1] ?? '';
-        const c3 = src[i + 2] ?? '';
-        // Triple-quoted string: """...""" or '''...'''
-        if ((c === '"' || c === "'") && c2 === c && c3 === c) {
-            const quote = c;
-            const start = i;
-            i += 3;
-            while (i < n) {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === quote && src[i + 1] === quote && src[i + 2] === quote) {
-                    i += 3;
-                    break;
-                }
-                i++;
-            }
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // Single-line string: '...' or "..."
-        if (c === '"' || c === "'") {
-            const quote = c;
-            i++;
-            while (i < n && src[i] !== quote) {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === '\n')
-                    break; // unterminated
-                i++;
-            }
-            if (i < n && src[i] === quote)
-                i++;
-            continue;
-        }
-        // Line comment
-        if (c === '#') {
-            const start = i;
-            while (i < n && src[i] !== '\n')
-                i++;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        i++;
-    }
-    return out.join('');
-}
-// ---------- Ruby ----------
-function stripRuby(src) {
-    const out = src.split('');
-    let i = 0;
-    const n = src.length;
-    let atLineStart = true;
-    while (i < n) {
-        const c = src[i];
-        // =begin / =end block comments must be at start of line (after optional whitespace)
-        if (atLineStart && c === '=' && src.startsWith('=begin', i)) {
-            const start = i;
-            // consume to matching =end at line start
-            i += '=begin'.length;
-            while (i < n) {
-                if (src[i] === '\n') {
-                    // check next line for =end
-                    let j = i + 1;
-                    while (j < n && (src[j] === ' ' || src[j] === '\t'))
-                        j++;
-                    if (src.startsWith('=end', j)) {
-                        i = j + '=end'.length;
-                        // consume rest of that line
-                        while (i < n && src[i] !== '\n')
-                            i++;
-                        break;
-                    }
-                }
-                i++;
-            }
-            blankRange(out, start, i, src);
-            atLineStart = i > 0 && src[i - 1] === '\n';
-            continue;
-        }
-        // String literals
-        if (c === '"' || c === "'") {
-            const quote = c;
-            i++;
-            while (i < n && src[i] !== quote) {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === '\n')
-                    break;
-                i++;
-            }
-            if (i < n && src[i] === quote)
-                i++;
-            atLineStart = false;
-            continue;
-        }
-        // Line comment
-        if (c === '#') {
-            const start = i;
-            while (i < n && src[i] !== '\n')
-                i++;
-            blankRange(out, start, i, src);
-            atLineStart = false;
-            continue;
-        }
-        if (c === '\n') {
-            atLineStart = true;
-            i++;
-            continue;
-        }
-        if (c === ' ' || c === '\t') {
-            // whitespace doesn't change atLineStart
-            i++;
-            continue;
-        }
-        atLineStart = false;
-        i++;
-    }
-    return out.join('');
-}
-// ---------- C-style (JS/TS/Java/C#/Swift) ----------
-function stripCStyle(src, allowSingleQuoteStrings) {
-    const out = src.split('');
-    let i = 0;
-    const n = src.length;
-    while (i < n) {
-        const c = src[i];
-        const c2 = src[i + 1] ?? '';
-        // Block comment
-        if (c === '/' && c2 === '*') {
-            const start = i;
-            i += 2;
-            while (i < n && !(src[i] === '*' && src[i + 1] === '/'))
-                i++;
-            if (i < n)
-                i += 2;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // Line comment
-        if (c === '/' && c2 === '/') {
-            const start = i;
-            while (i < n && src[i] !== '\n')
-                i++;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // String literals
-        if (c === '"' || (allowSingleQuoteStrings && c === "'") || c === '`') {
-            const quote = c;
-            i++;
-            while (i < n && src[i] !== quote) {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                // Template literal can span lines; regular strings break on newline (treat as unterminated)
-                if (quote !== '`' && src[i] === '\n')
-                    break;
-                i++;
-            }
-            if (i < n && src[i] === quote)
-                i++;
-            continue;
-        }
-        i++;
-    }
-    return out.join('');
-}
-// ---------- PHP ----------
-function stripPhp(src) {
-    const out = src.split('');
-    let i = 0;
-    const n = src.length;
-    while (i < n) {
-        const c = src[i];
-        const c2 = src[i + 1] ?? '';
-        // Block comment
-        if (c === '/' && c2 === '*') {
-            const start = i;
-            i += 2;
-            while (i < n && !(src[i] === '*' && src[i + 1] === '/'))
-                i++;
-            if (i < n)
-                i += 2;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // // line comment
-        if (c === '/' && c2 === '/') {
-            const start = i;
-            while (i < n && src[i] !== '\n')
-                i++;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // # line comment (PHP supports both)
-        if (c === '#') {
-            const start = i;
-            while (i < n && src[i] !== '\n')
-                i++;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // String literals: ', ", ` (PHP doesn't really use backticks for strings,
-        // but it does have shell-exec backticks; treating as a string is fine here)
-        if (c === '"' || c === "'" || c === '`') {
-            const quote = c;
-            i++;
-            while (i < n && src[i] !== quote) {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === '\n')
-                    break;
-                i++;
-            }
-            if (i < n && src[i] === quote)
-                i++;
-            continue;
-        }
-        i++;
-    }
-    return out.join('');
-}
-// ---------- Go ----------
-function stripGo(src) {
-    const out = src.split('');
-    let i = 0;
-    const n = src.length;
-    while (i < n) {
-        const c = src[i];
-        const c2 = src[i + 1] ?? '';
-        // Block comment
-        if (c === '/' && c2 === '*') {
-            const start = i;
-            i += 2;
-            while (i < n && !(src[i] === '*' && src[i + 1] === '/'))
-                i++;
-            if (i < n)
-                i += 2;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // Line comment
-        if (c === '/' && c2 === '/') {
-            const start = i;
-            while (i < n && src[i] !== '\n')
-                i++;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // Raw string with backticks (no escapes, can span lines)
-        if (c === '`') {
-            i++;
-            while (i < n && src[i] !== '`')
-                i++;
-            if (i < n)
-                i++;
-            continue;
-        }
-        // Interpreted string with double quotes
-        if (c === '"') {
-            i++;
-            while (i < n && src[i] !== '"') {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === '\n')
-                    break;
-                i++;
-            }
-            if (i < n && src[i] === '"')
-                i++;
-            continue;
-        }
-        // Rune literal with single quotes (handle as a tiny string)
-        if (c === "'") {
-            i++;
-            while (i < n && src[i] !== "'") {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === '\n')
-                    break;
-                i++;
-            }
-            if (i < n && src[i] === "'")
-                i++;
-            continue;
-        }
-        i++;
-    }
-    return out.join('');
-}
-// ---------- Rust ----------
-function stripRust(src) {
-    const out = src.split('');
-    let i = 0;
-    const n = src.length;
-    while (i < n) {
-        const c = src[i];
-        const c2 = src[i + 1] ?? '';
-        // Nested block comment /* ... /* ... */ ... */
-        if (c === '/' && c2 === '*') {
-            const start = i;
-            i += 2;
-            let depth = 1;
-            while (i < n && depth > 0) {
-                if (src[i] === '/' && src[i + 1] === '*') {
-                    depth++;
-                    i += 2;
-                }
-                else if (src[i] === '*' && src[i + 1] === '/') {
-                    depth--;
-                    i += 2;
-                }
-                else {
-                    i++;
-                }
-            }
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // Line comment
-        if (c === '/' && c2 === '/') {
-            const start = i;
-            while (i < n && src[i] !== '\n')
-                i++;
-            blankRange(out, start, i, src);
-            continue;
-        }
-        // String literals
-        if (c === '"') {
-            i++;
-            while (i < n && src[i] !== '"') {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                i++;
-            }
-            if (i < n && src[i] === '"')
-                i++;
-            continue;
-        }
-        // Char literal — keep simple: skip 'x' or '\x'
-        if (c === "'") {
-            // Could be a lifetime, e.g. 'a, but those don't contain routing text
-            i++;
-            while (i < n && src[i] !== "'") {
-                if (src[i] === '\\' && i + 1 < n) {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === '\n')
-                    break;
-                i++;
-            }
-            if (i < n && src[i] === "'")
-                i++;
-            continue;
-        }
-        i++;
-    }
-    return out.join('');
-}
-//# sourceMappingURL=strip-comments.js.map