@chappibunny/repolens 1.16.2 → 1.16.4

package/src/analyzers/workspace-packages.js

@@ -0,0 +1,105 @@
+// Workspace members declared by the repository: root package.json `workspaces`
+// (npm / yarn / bun), pnpm-workspace.yaml `packages`, and lerna.json `packages`.
+// Only declared members are internal packages for the dependency graph. A stray
+// package.json (a test stub named `express`, a fixture, a vendored copy) is not.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+import { loadYaml } from "../utils/yaml.js";
+
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function cleanPattern(raw) {
+  if (typeof raw !== "string") return null;
+  let p = raw.trim();
+  if (!p || p.includes("\0")) return null;
+  const negated = p.startsWith("!");
+  if (negated) p = p.slice(1).trim();
+  p = p.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  if (!p || p.startsWith("/") || /^[A-Za-z]:/.test(p)) return null;
+  if (p.split("/").includes("..")) return null;
+  return { pattern: p, negated };
+}
+
+async function declaredPatterns(repoRoot) {
+  const sources = [];
+  const patterns = [];
+
+  const rootPkg = await readJson(path.join(repoRoot, "package.json"));
+  if (rootPkg?.workspaces) {
+    const list = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces.packages;
+    if (Array.isArray(list) && list.length > 0) {
+      sources.push("package.json workspaces");
+      patterns.push(...list);
+    }
+  }
+
+  try {
+    const doc = loadYaml(await fs.readFile(path.join(repoRoot, "pnpm-workspace.yaml"), "utf8"));
+    if (Array.isArray(doc?.packages) && doc.packages.length > 0) {
+      sources.push("pnpm-workspace.yaml");
+      patterns.push(...doc.packages);
+    }
+  } catch {
+    // no pnpm workspace
+  }
+
+  const lerna = await readJson(path.join(repoRoot, "lerna.json"));
+  if (lerna) {
+    const list = Array.isArray(lerna.packages) && lerna.packages.length > 0 ? lerna.packages : ["packages/*"];
+    sources.push("lerna.json");
+    patterns.push(...list);
+  }
+
+  return { sources, patterns };
+}
+
+/**
+ * @returns {Promise<{ sources: string[], packages: { name: string, dir: string, manifest: object }[] }>}
+ * `dir` is repository-relative with forward slashes ("" never occurs: the root is not a member).
+ */
+export async function listWorkspacePackages(repoRoot) {
+  const { sources, patterns } = await declaredPatterns(repoRoot);
+  const positive = [];
+  const negative = [];
+  for (const raw of patterns) {
+    const cleaned = cleanPattern(raw);
+    if (!cleaned) continue;
+    (cleaned.negated ? negative : positive).push(cleaned.pattern);
+  }
+  if (positive.length === 0) return { sources, packages: [] };
+
+  let manifests = [];
+  try {
+    manifests = await fg(positive.map((p) => `${p}/package.json`), {
+      cwd: repoRoot,
+      dot: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      unique: true,
+      ignore: ["**/node_modules/**", ...negative.map((p) => `${p}/package.json`), ...negative.map((p) => `${p}/**`)],
+    });
+  } catch {
+    manifests = [];
+  }
+
+  const byName = new Map();
+  for (const rel of manifests.sort()) {
+    const dir = path.posix.dirname(rel.replace(/\\/g, "/"));
+    if (!dir || dir === ".") continue;
+    const manifest = await readJson(path.join(repoRoot, rel));
+    if (!manifest || typeof manifest.name !== "string" || !manifest.name) continue;
+    const existing = byName.get(manifest.name);
+    if (!existing || dir.split("/").length < existing.dir.split("/").length) {
+      byName.set(manifest.name, { name: manifest.name, dir, manifest });
+    }
+  }
+  return { sources, packages: [...byName.values()] };
+}

package/src/badge.js

@@ -2,11 +2,17 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { analyzeComplexity, computeCodeHealth } from "./analyzers/complexity-analyzer.js";
 import { analyzeDependencyGraph } from "./analyzers/dependency-graph.js";
+import { badgeCoverageOk, coverageLine } from "./analyzers/language-coverage.js";
 import { analyzeJSDoc } from "./analyzers/jsdoc-analyzer.js";
 import { analyzeSecurityPatterns } from "./analyzers/security-patterns.js";
 import { GALLERY_URL, REPO_URL } from "./delivery/comment-constants.js";
 
 const SOURCE_EXT = new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".py", ".pyw", ".go"]);
+const OTHER_SOURCE_EXT = new Set([
+  ".rs", ".java", ".kt", ".kts", ".scala", ".rb", ".php", ".cs", ".swift",
+  ".c", ".cc", ".cpp", ".h", ".hpp", ".vue", ".svelte",
+]);
+const MAX_SOURCE_FILES = 20000;
 const SKIP_DIR = new Set([
   "node_modules", ".git", "dist", "build", "vendor", "target", "coverage",
   ".repolens", "__pycache__", ".cache",
@@ -119,15 +125,19 @@ export function compactHealth(health) {
   };
 }
 
-export async function listScoreFiles(root, { maxFiles = 2500 } = {}) {
-  const out = [];
+/**
+ * Walk the tree once. Up to `maxFiles` scored files are analyzed, but every source file
+ * (scored languages and others alike) is counted up to `maxSourceFiles`, with the same
+ * skip rules, so the language-coverage decision never compares a capped sample of one
+ * language against an uncapped count of another. `coverageTruncated` is true when that
+ * shared limit was hit, and the ratio is then an estimate.
+ */
+export async function listScoreFiles(root, { maxFiles = 2500, maxSourceFiles = MAX_SOURCE_FILES } = {}) {
+  const scored = [];
+  const others = [];
   const stack = [root];
-  let capped = false;
-  while (stack.length) {
-    if (out.length >= maxFiles) {
-      capped = true;
-      break;
-    }
+  let coverageTruncated = false;
+  walk: while (stack.length) {
     const dir = stack.pop();
     let entries;
     try {
@@ -146,33 +156,47 @@ export async function listScoreFiles(root, { maxFiles = 2500 } = {}) {
       }
       if (!entry.isFile()) continue;
       if (entry.name.endsWith(".snap")) continue;
-      if (!SOURCE_EXT.has(path.extname(entry.name))) continue;
-      if (out.length >= maxFiles) {
-        capped = true;
-        break;
+      const ext = path.extname(entry.name);
+      const isScored = SOURCE_EXT.has(ext);
+      if (!isScored && !OTHER_SOURCE_EXT.has(ext.toLowerCase())) continue;
+      if (scored.length + others.length >= maxSourceFiles) {
+        coverageTruncated = true;
+        break walk;
       }
       const rel = path.relative(root, full).replace(/\\/g, "/");
-      out.push(rel);
+      (isScored ? scored : others).push(rel);
     }
   }
-  out.sort();
-  return { files: out, capped };
+  const capped = scored.length > maxFiles || coverageTruncated;
+  const files = scored.slice(0, maxFiles).sort();
+  return {
+    files,
+    capped,
+    others: others.sort(),
+    coverageFiles: [...scored, ...others],
+    coverageTruncated,
+  };
 }
 
 export async function scoreRepository(root, { files, maxFiles = 2500 } = {}) {
   let list = files;
   let capped = false;
+  let coverageFiles = files;
+  let coverageTruncated = false;
   if (!list) {
     const walked = await listScoreFiles(root, { maxFiles });
     list = walked.files;
     capped = walked.capped;
+    coverageFiles = walked.coverageFiles;
+    coverageTruncated = walked.coverageTruncated;
   }
-  const complexity = await analyzeComplexity(list, root);
-  const depGraph = await analyzeDependencyGraph(list, root);
+  // Coverage is judged on every counted source file; only `list` is analyzed.
+  const complexity = await analyzeComplexity(list, root, { coverageFiles });
+  const depGraph = await analyzeDependencyGraph(list, root, { coverageFiles });
   const jsdoc = await analyzeJSDoc(list, root);
   const security = await analyzeSecurityPatterns(list, root);
   const health = computeCodeHealth(complexity, depGraph, jsdoc, security);
-  return { health, depGraph, files: list, capped };
+  return { health, depGraph, files: list, capped, coverageTruncated };
 }
 
 function resolveOutPaths(outPath) {
@@ -228,6 +252,23 @@ export async function runBadgeCli({
     return 1;
   }
   const total = scored.health?.stats?.totalFiles || 0;
+  const coverage = scored.health?.coverage;
+  if (scored.coverageTruncated) {
+    console.error(`Note: language coverage was estimated from the first ${MAX_SOURCE_FILES} source files.`);
+  }
+  if (coverage && !badgeCoverageOk(coverage)) {
+    if (coverage.status === "unsupported") {
+      console.error(`Not scored: ${coverageLine(coverage, "code health")}`);
+    } else {
+      const pct = Math.round((coverage.share || 0) * 100);
+      console.error(`Not scored: only ${coverage.analyzedBase} of ${coverage.totalBase} product source files (${pct}%) are ${"JavaScript/TypeScript, Python, or Go"}; ${coverageLine(coverage, "code health")}`);
+    }
+    console.error("No badge was printed: one score would not stand for this repository.");
+    return 2;
+  }
+  if (coverage?.status === "partial") {
+    console.error(`Partial coverage: ${coverageLine(coverage, "code health")}`);
+  }
   if (!total) {
     console.error("No source files analyzed.");
     console.error("Code health covers JavaScript, TypeScript, Python, and Go. Empty documentation was not scored.");

package/src/core/scan.js

@@ -186,6 +186,7 @@ function packageEntryFiles(pkg) {
  */
 function detectLanguagesFromFiles(files) {
   const languages = new Set();
+  const counts = new Map();
   
   // Extension to language mapping
   const extensionMap = {
@@ -241,9 +242,12 @@ function detectLanguagesFromFiles(files) {
     // types. They do not make the library a TypeScript project.
     if (ext === ".ts" && /\.d\.ts$/i.test(file)) continue;
     if (extensionMap[ext] === "TypeScript" && isTestPath(file)) continue;
-    languages.add(extensionMap[ext]);
+    const label = extensionMap[ext];
+    counts.set(label, (counts.get(label) || 0) + 1);
   }
 
+  // Most files first, so a C# repository with one docs script reads "C#, JavaScript".
+  for (const [label] of [...counts.entries()].sort((a, b) => b[1] - a[1])) languages.add(label);
   return languages;
 }
 
@@ -406,9 +410,8 @@ async function extractRepoMetadata(repoRoot, files = []) {
 
   // Merge languages detected from file extensions
   const fileLanguages = detectLanguagesFromFiles(files);
-  for (const lang of fileLanguages) {
-    metadata.languages.add(lang);
-  }
+  const manifestLanguages = [...metadata.languages];
+  metadata.languages = new Set([...fileLanguages, ...manifestLanguages]);
 
   // De-duplicate frameworks (in case detected from multiple sources)
   metadata.frameworks = [...new Set(metadata.frameworks)];
@@ -589,6 +592,7 @@ export async function scanRepo(cfg) {
   }
 
   const moduleCounts = new Map();
+  const moduleTestCounts = new Map();
   const flatKeys = new Set();
   const rootLabel = rootModuleLabel(repoRoot);
 
@@ -600,12 +604,14 @@ export async function scanRepo(cfg) {
     const key = moduleKeyForFile(file, cfg.module_roots || [], rootLabel);
     if (!norm(file).includes("/")) flatKeys.add(key);
     moduleCounts.set(key, (moduleCounts.get(key) || 0) + 1);
+    if (isTestPath(file)) moduleTestCounts.set(key, (moduleTestCounts.get(key) || 0) + 1);
   }
 
   const modules = [...moduleCounts.entries()]
     .map(([key, fileCount]) => ({
       key,
       fileCount,
+      ...(moduleTestCounts.get(key) ? { testFileCount: moduleTestCounts.get(key) } : {}),
       ...(flatKeys.has(key) ? { flat: true } : {}),
     }))
     .sort((a, b) => b.fileCount - a.fileCount);

package/src/docs/generate-doc-set.js

@@ -130,7 +130,7 @@ export async function generateDocumentSet(scanResult, config, diffData = null, p
   
   for (const docPlan of activeDocuments) {
     docIndex++;
-    const emptyReason = emptyDocumentReason(docPlan, { config, scanResult, graphqlResult });
+    const emptyReason = emptyDocumentReason(docPlan, { config, scanResult, graphqlResult, jsdocResult });
     if (emptyReason) {
       info(`[${docIndex}/${totalDocs}] Skipping ${docPlan.key}: ${emptyReason}`);
       continue;
@@ -244,10 +244,11 @@ export async function generateDocumentSet(scanResult, config, diffData = null, p
 
 /**
  * Documents that would only say "nothing found" are not written. A library has no GraphQL
- * schema and no routes, so those two pages would be noise. A document the config lists
+ * schema and no routes, so those two pages would be noise, and a CLI or library with no
+ * routes, no external API clients, and no documented exports has no API Surface to show. A document the config lists
  * explicitly in `documentation.sections` is always written.
  */
-export function emptyDocumentReason(docPlan, { config, scanResult, graphqlResult }) {
+export function emptyDocumentReason(docPlan, { config, scanResult, graphqlResult, jsdocResult = null }) {
   if (config?.documentation?.sections?.includes(docPlan.key)) return null;
   if (docPlan.key === "graphql_schema" && !graphqlResult?.detected) {
     return "no GraphQL schema detected";
@@ -255,9 +256,16 @@ export function emptyDocumentReason(docPlan, { config, scanResult, graphqlResult
   if (docPlan.key === "route_map" && !(scanResult?.pages?.length) && !(scanResult?.api?.length)) {
     return "no pages or API routes detected";
   }
+  if (docPlan.key === "api_surface" && !(scanResult?.api?.length) && !(scanResult?.externalApis?.length) && !hasDocumentedExports(jsdocResult)) {
+    return "no API routes, external API integrations, or documented exports detected";
+  }
   return null;
 }
 
+function hasDocumentedExports(jsdocResult) {
+  return Boolean(jsdocResult?.detected && Array.isArray(jsdocResult.exports) && jsdocResult.exports.length > 0);
+}
+
 async function generateDocument(docPlan, context) {
   const { key } = docPlan;
   const { scanResult, config, aiContext, moduleContext, flows, diffData, graphqlResult, tsResult, jsdocResult, depGraph, driftResult, securityResult, codeHealthResult, ownershipMap, pluginManager } = context;

package/src/help.js

@@ -32,6 +32,8 @@ It detects Python, Go, Rust, Java/Kotlin, JavaScript/TypeScript, Ruby, PHP,
 C#, Swift, and C/C++ (and combinations) and sets scan.include plus
 module_roots from the files it finds. A repository with no recognized
 language gets multi-language globs, not JavaScript-only defaults.
+Detection is not full analysis: the dependency graph and code health read
+JavaScript/TypeScript, Python, and Go only.
 
 The target directory must already exist.
 
@@ -129,9 +131,12 @@ Options:
   --help, -h            Show this help
 
 With no config, demo detects the repository language and scans matching
-files (Python, Go, Rust, Java, JavaScript, and others). It does not publish
-to Notion or Confluence. A scan that matches 0 files exits 2 and does not
-write empty docs.
+files (Python, Go, Rust, Java, JavaScript, and others) for modules and file
+structure. The dependency graph and code health cover JavaScript/TypeScript,
+Python, and Go only; for other languages (for example Java, Kotlin, or C#)
+those pages say the language is not supported yet instead of showing a
+score. It does not publish to Notion or Confluence. A scan that matches
+0 files exits 2 and does not write empty docs.
 
 The target directory must already exist.
 

package/src/renderers/render.js

@@ -151,6 +151,18 @@ function describeModule(key, depRole = null, evidence = {}) {
   return base;
 }
 
+// A module whose files are mostly tests and fixtures is not "Application module".
+// The file count stays the same; the role says how much of it is test code.
+export function describeModuleWithTests(module, desc) {
+  const total = Number(module?.fileCount) || 0;
+  const tests = Number(module?.testFileCount) || 0;
+  if (!total || tests * 2 < total) return desc;
+  if (/^Test suites and fixtures/.test(desc)) return desc;
+  const role = desc.replace(/^Application module( · )?/, "");
+  const base = `Mostly tests and fixtures (${tests} of ${total} files)`;
+  return role ? `${base} · ${role}` : base;
+}
+
 export function renderModuleCatalog(cfg, scan, ownershipMap = {}, depGraph = null) {
   const hasOwnership = Object.keys(ownershipMap).length > 0;
   const moduleMetrics = computeModuleLevelMetrics(depGraph, scan.modules);
@@ -192,7 +204,7 @@ export function renderModuleCatalog(cfg, scan, ownershipMap = {}, depGraph = nul
 
   for (const module of scan.modules.slice(0, 100)) {
     const depRole = describeModuleDepRole(module.key, moduleMetrics);
-    const desc = describeModule(module.key, depRole, moduleEvidence(module.key, depGraph));
+    const desc = describeModuleWithTests(module, describeModule(module.key, depRole, moduleEvidence(module.key, depGraph)));
     const owners = ownershipMap[module.key];
     if (hasOwnership) {
       lines.push(`| \`${module.key}\` | ${module.fileCount} | ${desc} | ${owners ? owners.join(", ") : "—"} |`);
@@ -236,7 +248,7 @@ export function renderApiSurface(cfg, scan, jsdocResult = null) {
 
   if (!scan.api.length) {
     lines.push(
-      `No API routes were detected in this scan. If your project uses a routing framework (Express, Fastify, NestJS, etc.), ensure the relevant directories are included in your \`scan.include\` patterns.`,
+      `No HTTP API routes were detected. RepoLens reads Next.js API routes and Express-style \`app.get(...)\` / \`router.post(...)\` handlers in JavaScript and TypeScript; libraries and CLIs usually have none.`,
       ``
     );
   } else {

package/src/renderers/renderAnalysis.js

@@ -4,6 +4,8 @@
 //   - Dependency Graph
 //   - Architecture Drift
 
+import { coverageNotice } from "../analyzers/language-coverage.js";
+
 export function renderGraphQLSchema(graphqlResult) {
   if (!graphqlResult?.detected) {
     return [
@@ -316,6 +318,10 @@ export function renderTypeGraph(tsResult) {
 }
 
 export function renderDependencyGraph(depResult) {
+  const coverageLines = coverageNotice(depResult?.coverage, "import analysis");
+  if (!depResult?.nodes?.length && depResult?.coverage?.status === "unsupported") {
+    return ["# Dependency Graph", "", ...coverageLines].join("\n");
+  }
   if (!depResult?.nodes?.length) {
     return [
       "# Dependency Graph",
@@ -332,6 +338,7 @@ export function renderDependencyGraph(depResult) {
   lines.push("");
   lines.push(`> ${depResult.summary}`);
   lines.push("");
+  lines.push(...coverageLines);
   lines.push("This document maps every import relationship in the codebase, identifies the most-connected modules, and flags circular dependencies that may complicate refactoring or increase build times.");
   lines.push("");
 
@@ -349,6 +356,8 @@ export function renderDependencyGraph(depResult) {
     lines.push(`| External packages | ${s.externalDeps} |`);
   }
   lines.push(`| Circular dependencies | ${s.cycles} |`);
+  if (s.typeOnlyCycles > 0) lines.push(`| Type-only cycles (not runtime, not counted) | ${s.typeOnlyCycles} |`);
+  if (s.typeOnlyEdges > 0) lines.push(`| Type-only imports (not import edges) | ${s.typeOnlyEdges} |`);
   lines.push(`| Orphan files (no imports or importers) | ${s.orphanFiles} |`);
   lines.push("");
 
@@ -388,9 +397,27 @@ export function renderDependencyGraph(depResult) {
   }
 
   if (Array.isArray(depResult.typeOnlyReports) && depResult.typeOnlyReports.length > 0) {
+    const reports = depResult.typeOnlyReports;
     lines.push("## Type-only cycles");
     lines.push("");
-    lines.push(`**${depResult.typeOnlyReports.length}** cycle${depResult.typeOnlyReports.length === 1 ? " exists" : "s exist"} only through \`import type\` / \`export type\`. They are not runtime dependencies. Priority: Low — type-only imports; verify.`);
+    lines.push(`**${reports.length}** cycle${reports.length === 1 ? " closes" : "s close"} only through type-only imports. The compiler removes those imports, so there is no runtime cycle. They are not counted as circular dependencies and do not lower the health score. Priority: Low — type-only imports; verify.`);
+    lines.push("");
+    lines.push("A type-only import is `import type`, `export type`, or an import list whose names are all marked `type` (*syntax*). In TypeScript files it is also an import whose names are interfaces or type aliases, or are used only in type positions (*inferred*). Inference is off under `verbatimModuleSyntax`, `preserveValueImports`, `importsNotUsedAsValues: \"preserve\"`, or `erasableSyntaxOnly`, which keep the import at runtime.");
+    lines.push("");
+    const limit = Math.min(reports.length, 20);
+    for (let i = 0; i < limit; i++) {
+      const report = reports[i];
+      const pathText = Array.isArray(report.path) ? report.path.join("` → `") : String(report.path);
+      lines.push(`${i + 1}. \`${pathText}\``);
+      const links = Array.isArray(report.typeOnlyLinks) ? report.typeOnlyLinks : [];
+      if (links.length > 0) {
+        const text = links.map((link) => `\`${link.from}\` → \`${link.to}\` (${link.reason === "inferred" ? "inferred" : "syntax"})`).join("; ");
+        lines.push(`   Type-only link${links.length === 1 ? "" : "s"}: ${text}`);
+      }
+    }
+    if (reports.length > 20) {
+      lines.push(`\n*...and ${reports.length - 20} more type-only cycles*`);
+    }
     lines.push("");
   }
 
@@ -427,7 +454,7 @@ export function renderDependencyGraph(depResult) {
 
   lines.push("---");
   lines.push("");
-  lines.push("*Generated by RepoLens import analysis. Dependency detection covers JavaScript and TypeScript (ES modules, dynamic import, CommonJS, re-exports; comments, strings, type-only imports, and Node.js built-ins are skipped), Python (`import` / `from ... import`, including relative imports; `TYPE_CHECKING` blocks are skipped), and Go (`go.mod` module paths, hubs grouped by package). Go `*_test.go` files are not part of the graph.*");
+  lines.push("*Generated by RepoLens import analysis. Dependency detection covers JavaScript and TypeScript (ES modules, dynamic import, CommonJS, re-exports; comments, strings, and Node.js built-ins are skipped; type-only imports, including TypeScript imports whose names are used only as types, are not import edges), Python (`import` / `from ... import`, including relative imports; `TYPE_CHECKING` blocks are skipped), and Go (`go.mod` module paths, hubs grouped by package). Go `*_test.go` files are not part of the graph.*");
   lines.push("");
 
   return lines.join("\n");
@@ -526,6 +553,10 @@ export function renderArchitectureDrift(driftResult) {
 }
 
 export function renderCodeHealth(healthResult) {
+  const coverageLines = coverageNotice(healthResult?.coverage, "code health");
+  if (!healthResult?.modules?.length && healthResult?.coverage?.status === "unsupported") {
+    return ["# Code Health Report", "", ...coverageLines].join("\n");
+  }
   if (!healthResult?.modules?.length) {
     return [
       "# Code Health Report",
@@ -544,6 +575,7 @@ export function renderCodeHealth(healthResult) {
   lines.push("");
   lines.push(`> ${healthResult.summary}`);
   lines.push("");
+  lines.push(...coverageLines);
   lines.push("This report synthesizes complexity, coupling, documentation, and security signals into a single health score per module. Lower scores indicate higher risk and maintenance burden.");
   lines.push("");
 

package/src/utils/js-lexer.js

@@ -0,0 +1,146 @@
+// Remove JavaScript/TypeScript comments while keeping every string, template literal
+// (including `${...}` expressions, which may hold their own comments and strings),
+// and regular-expression literal intact. Comment text becomes spaces; newlines stay,
+// so offsets and line numbers still match the source.
+
+const REGEX_PREFIX_WORDS = new Set([
+  "return", "typeof", "instanceof", "in", "of", "new", "delete", "void", "throw",
+  "case", "do", "else", "yield", "await",
+]);
+
+function blank(text) {
+  return text.replace(/[^\n]/g, " ");
+}
+
+function isIdentPart(ch) {
+  return /[A-Za-z0-9_$]/.test(ch || "");
+}
+
+export function stripJsComments(source) {
+  const src = String(source ?? "");
+  const n = src.length;
+  let out = "";
+  let i = 0;
+  // Stack of contexts: { type: "code", depth, inTemplate } or { type: "template" }.
+  const stack = [{ type: "code", depth: 0, inTemplate: false }];
+  // Last significant code token, to tell a regex literal from division.
+  let lastChar = "";
+  let lastWord = "";
+
+  while (i < n) {
+    const ctx = stack[stack.length - 1];
+    const ch = src[i];
+
+    if (ctx.type === "template") {
+      if (ch === "\\") {
+        out += src.slice(i, i + 2);
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        out += ch;
+        i += 1;
+        stack.pop();
+        lastChar = "`";
+        lastWord = "";
+        continue;
+      }
+      if (ch === "$" && src[i + 1] === "{") {
+        out += "${";
+        i += 2;
+        stack.push({ type: "code", depth: 0, inTemplate: true });
+        lastChar = "{";
+        lastWord = "";
+        continue;
+      }
+      out += ch;
+      i += 1;
+      continue;
+    }
+
+    // code context
+    const next = src[i + 1];
+    if (ch === "/" && next === "/") {
+      const nl = src.indexOf("\n", i);
+      const end = nl === -1 ? n : nl;
+      out += blank(src.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      const close = src.indexOf("*/", i + 2);
+      const end = close === -1 ? n : close + 2;
+      out += blank(src.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      while (j < n) {
+        if (src[j] === "\\") { j += 2; continue; }
+        if (src[j] === ch || src[j] === "\n") { j += 1; break; }
+        j += 1;
+      }
+      out += src.slice(i, Math.min(j, n));
+      i = Math.min(j, n);
+      lastChar = ch;
+      lastWord = "";
+      continue;
+    }
+    if (ch === "`") {
+      out += ch;
+      i += 1;
+      stack.push({ type: "template" });
+      continue;
+    }
+    if (ch === "/") {
+      const regexAllowed = lastChar === "" || "([{,;:!?&|~^=<>+-*%".includes(lastChar) || REGEX_PREFIX_WORDS.has(lastWord);
+      if (regexAllowed) {
+        let j = i + 1;
+        let inClass = false;
+        while (j < n) {
+          const c = src[j];
+          if (c === "\\") { j += 2; continue; }
+          if (c === "\n") break;
+          if (c === "[") inClass = true;
+          else if (c === "]") inClass = false;
+          else if (c === "/" && !inClass) { j += 1; break; }
+          j += 1;
+        }
+        while (j < n && /[a-z]/i.test(src[j])) j += 1;
+        out += src.slice(i, j);
+        i = j;
+        lastChar = ")";
+        lastWord = "";
+        continue;
+      }
+    }
+    if (ch === "{") ctx.depth += 1;
+    if (ch === "}") {
+      if (ctx.inTemplate && ctx.depth === 0) {
+        out += ch;
+        i += 1;
+        stack.pop();
+        continue;
+      }
+      ctx.depth -= 1;
+    }
+    if (isIdentPart(ch)) {
+      let j = i;
+      while (j < n && isIdentPart(src[j])) j += 1;
+      const word = src.slice(i, j);
+      out += word;
+      i = j;
+      lastWord = word;
+      lastChar = word[word.length - 1];
+      continue;
+    }
+    out += ch;
+    i += 1;
+    if (!/\s/.test(ch)) {
+      lastChar = ch;
+      lastWord = "";
+    }
+  }
+  return out;
+}