deslop-js 0.0.25 → 0.5.8

package/README.md

@@ -0,0 +1,308 @@
+# deslop-js
+
+[![version](https://img.shields.io/npm/v/deslop-js?style=flat&colorA=000000&colorB=000000)](https://npmjs.com/package/deslop-js)
+[![downloads](https://img.shields.io/npm/dt/deslop-js.svg?style=flat&colorA=000000&colorB=000000)](https://npmjs.com/package/deslop-js)
+
+Deslop JavaScript code.
+
+Finds unused files, dead exports, dead dependencies, circular imports, redundant aliases, duplicate types, and other DRY violations. Each finding carries a confidence tier so you can gate CI on the high-signal ones and treat the rest as code-review prompts.
+
+## Install
+
+```bash
+npm install deslop-js
+```
+
+## CLI
+
+The `deslop-cli` package provides a command-line interface:
+
+```bash
+npm install -g deslop-cli
+```
+
+### Quick start
+
+```bash
+# scan the current directory
+deslop
+
+# scan a specific project
+deslop ./my-project
+
+# use the explicit analyze sub-command (equivalent to the above)
+deslop analyze ./my-project
+```
+
+### Options
+
+```bash
+deslop [root] [options]
+
+# custom entry points
+deslop --entry src/main.ts --entry src/worker.ts
+
+# ignore test files
+deslop --ignore "**/*.test.ts" --ignore "**/__mocks__/**"
+
+# only scan specific extensions
+deslop --extensions .ts .tsx
+
+# resolve path aliases via tsconfig
+deslop --tsconfig ./tsconfig.json
+
+# add explicit path aliases (in addition to the auto-detected ones)
+deslop --paths "@app/*=src/*" --paths "@lib/*=packages/lib/*"
+
+# include type-only exports in results
+deslop --report-types
+
+# report unused exports from entry files too
+deslop --include-entry-exports
+
+# output results as JSON (useful for CI or piping to other tools)
+deslop --json
+
+# exit with code 1 when unused code is found (for CI gates)
+deslop --fail-on-issues
+
+# exit with code 1 when circular imports are found
+deslop --fail-on-cycles
+```
+
+### CI example
+
+```bash
+# fail the build if there are unused exports or circular imports
+deslop ./src --fail-on-issues --fail-on-cycles --ignore "**/*.test.ts"
+```
+
+## Programmatic Usage
+
+```ts
+import { analyze, defineConfig } from "deslop-js";
+
+const config = defineConfig({ rootDir: "./my-project" });
+const result = await analyze(config);
+
+// unused-code findings (syntactic)
+result.unusedFiles; // files unreachable from any entry point
+result.unusedExports; // exported symbols never imported
+result.unusedDependencies; // package.json deps not imported anywhere
+result.circularDependencies; // import cycles
+
+// redundancy / DRY findings (syntactic, on by default)
+result.redundantAliases; // `import { x as x }`, useless re-export renames
+result.duplicateExports; // same name exported twice from one module
+result.duplicateImports; // same specifier imported multiple times
+result.redundantTypePatterns; // `T & {}`, `Partial<Partial<T>>`, etc.
+result.identityWrappers; // `const wrap = (x) => fn(x)`
+result.duplicateTypeDefinitions; // same-shape type declared in N files
+result.duplicateInlineTypes; // anonymous `{ a, b, c }` repeated across modules
+result.simplifiableFunctions; // `() => { return x }`, `await x; return x`
+result.simplifiableExpressions; // `!!x`, `x ? x : y`, `cond ? true : false`
+result.duplicateConstants; // same literal value across files
+result.crossFileDuplicateExports; // same export name shipped by 2+ files that share an importer
+result.reExportCycles; // `export * from "./a"` cycles (self-loop or multi-node)
+result.privateTypeLeaks; // exported signature references a non-exported local type
+
+// duplicate-block detection (token-based copy-paste; on by default, disable via `duplicateBlocks.enabled: false`)
+result.duplicateBlocks; // suffix-array + LCP detected duplicate code blocks
+result.duplicateBlockClusters; // clones grouped by file set + refactoring suggestions
+result.shadowedDirectoryPairs; // directory pairs with many identical files
+
+// feature flag inventory (on by default, disable via `featureFlags.enabled: false`)
+result.featureFlags; // LaunchDarkly/Statsig/Unleash/PostHog/Vercel Flags/process.env.* uses
+
+// function complexity hotspots (on by default, disable via `complexity.enabled: false`)
+result.complexFunctions; // McCabe cyclomatic + SonarSource cognitive per function
+
+// TypeScript-specific smells (on by default)
+result.unnecessaryAssertions; // `x as unknown as T`, `x as any`, `x!!`, `<T>x`, `"foo"!`
+result.lazyImportsAtTopLevel; // top-level `await import(...)` / `.then(...)` that should be static
+result.commonjsInEsm; // `require()`, `module.exports`, `exports.x` inside ESM modules
+result.typeScriptEscapeHatches; // `// @ts-ignore`, `// @ts-nocheck`, undocumented `@ts-expect-error`
+
+// semantic findings (type-aware; on by default, disable via `semantic: { enabled: false }`)
+result.unusedTypes; // type aliases / interfaces never referenced
+result.unusedEnumMembers; // enum members no reference site uses
+result.unusedClassMembers; // class members no caller invokes (skips React/Angular lifecycle methods)
+result.misclassifiedDependencies; // `dependencies` entries used only as types
+
+// diagnostics
+result.analysisErrors; // structured errors from any pipeline stage
+result.totalFiles;
+result.totalExports;
+result.analysisTimeMs;
+```
+
+## Programmatic Options
+
+`defineConfig` accepts a required `rootDir` and optional overrides:
+
+```ts
+const config = defineConfig({
+  rootDir: "./my-project",
+  entryPatterns: ["src/main.ts"],
+  ignorePatterns: ["**/*.test.ts"],
+  tsConfigPath: "./tsconfig.json",
+  reportTypes: true,
+  includeEntryExports: true,
+  reportRedundancy: true,
+  semantic: { enabled: true },
+});
+```
+
+| Option                | Type                                    | Default                                                          | Description                                                                                             |
+| --------------------- | --------------------------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `rootDir`             | `string`                                | required                                                         | Project root directory                                                                                  |
+| `entryPatterns`       | `string[]`                              | auto-detected                                                    | Entry point glob patterns                                                                               |
+| `ignorePatterns`      | `string[]`                              | `[]`                                                             | Glob patterns to exclude from analysis                                                                  |
+| `includeExtensions`   | `string[]`                              | `[".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cjs", ".cts"]` | File extensions to scan                                                                                 |
+| `tsConfigPath`        | `string \| undefined`                   | `undefined`                                                      | Path to tsconfig.json for path alias resolution                                                         |
+| `paths`               | `Record<string, string[]> \| undefined` | `undefined`                                                      | Explicit path-alias mappings (e.g. `{ "@app/*": ["src/*"] }`), resolved alongside auto-detected aliases |
+| `reportTypes`         | `boolean`                               | `false`                                                          | Include type-only exports in `unusedExports`                                                            |
+| `includeEntryExports` | `boolean`                               | `false`                                                          | Report unused exports from entry files                                                                  |
+| `reportRedundancy`    | `boolean`                               | `true`                                                           | Emit the redundancy / DRY findings listed above                                                         |
+| `semantic`            | `SemanticConfig`                        | `undefined`                                                      | Opt-in TypeScript type-aware analysis (see below)                                                       |
+
+Path aliases are auto-detected by default — from `tsconfig` `paths`, Vite (`resolve.alias`), webpack, Babel (`module-resolver`), and Jest (`moduleNameMapper`) configs, plus the workspace layout (a `@scope/<dir>` import resolves to the matching workspace package even when its `package.json` name differs). Use `paths` / `--paths` only for mappings none of those cover.
+
+### Semantic (type-aware) analysis
+
+On by default. Loads the TypeScript program when the project has a valid `tsconfig.json`; gracefully no-ops on JS-only projects. Disable with `semantic: { enabled: false }` to skip the ~1–3s program load.
+
+```ts
+const config = defineConfig({
+  rootDir: "./my-project",
+  semantic: {
+    enabled: true,
+    reportUnusedTypes: true,
+    reportUnusedEnumMembers: true,
+    reportUnusedClassMembers: false, // off by default, noisy on framework code
+    reportMisclassifiedDependencies: true,
+    reportRedundantVariableAliases: true,
+    reportRoundTripAliases: true,
+  },
+});
+```
+
+| Option                            | Default     | Notes                                                                                                                                                          |
+| --------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `enabled`                         | `false`     | Master switch; semantic analysis loads the TS program and adds ~1–3s per scan                                                                                  |
+| `reportUnusedTypes`               | `true`      | Type aliases / interfaces / type-only exports never referenced                                                                                                 |
+| `reportUnusedEnumMembers`         | `true`      | Enum members no reference site reads or writes                                                                                                                 |
+| `reportUnusedClassMembers`        | **`false`** | Subclass overrides, framework method-by-name invocation (`@HttpGet`, lifecycle hooks) produce too many stylistic FPs to enable by default. Opt in selectively. |
+| `reportMisclassifiedDependencies` | `true`      | `dependencies` packages used only via `import type`                                                                                                            |
+| `reportRedundantVariableAliases`  | `true`      | Local aliases like `const X = Y; export { X }`                                                                                                                 |
+| `reportRoundTripAliases`          | `true`      | `import { X as Y } from "./a"; export { Y as X }`                                                                                                              |
+
+### Duplicate blocks (token-based copy-paste detection)
+
+On by default. Detects maximal duplicated token sequences across files via a suffix array + LCP pass over a normalized AST token stream. Tune thresholds or disable entirely:
+
+```ts
+const config = defineConfig({
+  rootDir: "./my-project",
+  duplicateBlocks: {
+    enabled: true, // default
+    mode: "semantic", // "strict" preserves identifiers/literals; "semantic" (default) blinds them
+    minTokens: 50,
+    minLines: 5,
+    minOccurrences: 2,
+    skipLocal: false, // true => only report cross-directory duplicates
+  },
+});
+```
+
+Surfaces in three result fields:
+
+- `result.duplicateBlocks` — every duplicated block group with all its occurrences
+- `result.duplicateBlockClusters` — duplicate blocks sharing the same file set, plus an `extract-function` / `extract-module` refactoring hint
+- `result.shadowedDirectoryPairs` — directory pairs (e.g. `src/` and `deno/lib/`) whose files mirror each other
+
+### Feature flag inventory
+
+On by default. Scans the codebase for every place a feature flag is _read_ and produces a finding per use. The detector recognizes three families:
+
+1. **Env-var flags** — `process.env.X` whose name starts with one of the built-in prefixes `FEATURE_`, `NEXT_PUBLIC_FEATURE_`, `REACT_APP_FEATURE_`, `VITE_FEATURE_`, `NUXT_PUBLIC_FEATURE_`, `ENABLE_`, `FF_`, `FLAG_`, `TOGGLE_` (extend with `extraEnvPrefixes`).
+2. **SDK calls** with provider attribution — LaunchDarkly (`useFlag`/`variation`/...), Statsig (`useGate`/`checkGate`/...), Unleash (`isEnabled`/`getVariant`), GrowthBook (`isOn`/`isOff`/`getFeatureValue`), Split (`getTreatment`), PostHog (`useFeatureFlagEnabled`/...), ConfigCat, Flagsmith, Optimizely, Eppo, and Vercel Flags (`flag()` / `evaluate()` from `flags` or `@vercel/flags`).
+3. **Config-object access** — `config.features.X` style; off by default because it's heuristic. Opt in with `detectConfigObjects: true`.
+
+Each finding carries `name`, `path`, `line`, `column`, `sdkProvider` (when known), and `kind: "env-var" | "sdk-call" | "config-object"`. The detector also tracks the surrounding `if` / ternary guard span and sets `guardsDeadCode: true` when an `unusedExports` finding falls inside that guard — so a flag whose enabled branch contains only dead code lights up immediately.
+
+**The actionable angle**: cross-reference `result.featureFlags` with your live flag dashboard.
+
+- Flags in the dashboard but missing from `result.featureFlags` → no longer read by the codebase, safe to retire from the platform.
+- Flags in `result.featureFlags` with `guardsDeadCode: true` → the guarded code is unreachable, delete both the flag and its body.
+
+```ts
+const config = defineConfig({
+  rootDir: "./my-project",
+  featureFlags: {
+    enabled: true, // default
+    extraEnvPrefixes: ["MYAPP_FF_"],
+    extraSdkFunctionNames: ["myCustomFlag"],
+    detectConfigObjects: false, // heuristic config.features.x — opt in if you use that pattern
+  },
+});
+```
+
+### Function complexity (cyclomatic + cognitive)
+
+On by default. Reports per-function McCabe cyclomatic and SonarSource cognitive complexity, function size, and parameter count for every function that breaches at least one threshold. Tune the thresholds or disable entirely:
+
+```ts
+const config = defineConfig({
+  rootDir: "./my-project",
+  complexity: {
+    enabled: true, // default
+    cyclomaticThreshold: 10,
+    cognitiveThreshold: 15,
+    paramCountThreshold: 5,
+    functionLineThreshold: 80,
+  },
+});
+```
+
+### TypeScript code smells
+
+On by default. Four families of TypeScript-specific patterns surfaced at high or medium confidence — no extra config required.
+
+```ts
+result.unnecessaryAssertions; // type assertions that drop type-safety or do nothing
+result.lazyImportsAtTopLevel; // dynamic imports at the module top level
+result.commonjsInEsm; // CommonJS forms inside ESM modules
+result.typeScriptEscapeHatches; // @ts-ignore / @ts-nocheck / undocumented @ts-expect-error
+```
+
+| Finding                          | Kinds                                                                                                                                                                             |
+| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `result.unnecessaryAssertions`   | `redundant-double-assertion` (`x as unknown as T`), `assertion-to-any`, `redundant-non-null-on-literal` (`"foo"!`), `double-non-null` (`x!!`), `angle-bracket-assertion` (`<T>x`) |
+| `result.lazyImportsAtTopLevel`   | `top-level-await-import`, `top-level-then-import`                                                                                                                                 |
+| `result.commonjsInEsm`           | `require`, `module-exports`, `exports-assignment`                                                                                                                                 |
+| `result.typeScriptEscapeHatches` | `ts-ignore`, `ts-nocheck`, `ts-expect-error-without-explanation`                                                                                                                  |
+
+ESM detection follows the runtime rules: `.mts`/`.mjs` extensions are always ESM, `.cts`/`.cjs` are always CommonJS, and other files inherit from the nearest `package.json`'s `"type"` field.
+
+## Findings have confidence tiers
+
+Every redundancy / semantic finding carries `confidence: "high" | "medium" | "low"`. Use `"high"` for CI gates; `"medium"` and `"low"` are best treated as code-review prompts since intent is sometimes unknowable from syntax alone (e.g. `?? null` may be required by a typed callback signature).
+
+## Error handling
+
+`analyze()` never throws on a corrupted file, unparseable `tsconfig`, or missing dependency. Failures surface as `analysisErrors: DeslopError[]` with structured `code`, `module`, `severity`, and `path` fields. See `errors.ts` for the full taxonomy. Errors at `severity: "info"` (empty files, binary files, minified bundles skipped from redundancy analysis) are informational and do not indicate problems.
+
+## Development
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+pnpm lint
+pnpm format
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -96,8 +96,8 @@ const DEFAULT_EXCLUSIONS = [
 	"**/*.min.mjs",
 	"**/mockServiceWorker.js"
 ];
-const SCRIPT_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|tsc|npx|bun|esr|esno|jiti|babel-node|zx)\s+(?:(?:-[\w-]+(?:[=\s][\w./@=-]+)?\s+)|(?:[\w/-]+\s+))*([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))(?:\s|$)/;
-const SCRIPT_EXTENSIONLESS_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|bun|esr|esno|jiti|babel-node|zx)\s+(?:(?:-[\w-]+(?:[=\s][\w./@=-]+)?\s+))*((?:[./]|[\w@][\w@-]*\/)[\w./@-]+)(?:\s|$)/;
+const SCRIPT_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|tsc|npx|bun|esr|esno|jiti|babel-node|zx)\s+(?:\S+\s+)*?([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))(?:\s|$)/;
+const SCRIPT_EXTENSIONLESS_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|bun|esr|esno|jiti|babel-node|zx)\s+(?:\S+\s+)*?((?:[./]|[\w@][\w@-]*\/)[\w./@-]+)(?:\s|$)/;
 const SCRIPT_CONFIG_FILE_PATTERN = /--config\s+([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))/;
 const SCRIPT_ENTRY_PATTERNS = [];
 const DEFAULT_ENTRY_GLOBS = [
@@ -1582,7 +1582,7 @@ const extractMdxImportsExports = (sourceText) => {
 	return statements.join("\n");
 };
 const ASTRO_FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---/;
-const ASTRO_SCRIPT_TAG_PATTERN = /<script\b([^>]*?)\/>|<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+const ASTRO_SCRIPT_TAG_PATTERN = /<script\b([^>]*?)\/>|<script\b([^>]*)>([\s\S]*?)<\/script\b[^>]*>/gi;
 const ASTRO_SCRIPT_SRC_ATTRIBUTE_PATTERN = /\bsrc\s*=\s*["']([^"']+)["']/i;
 const extractAstroSources = (sourceText) => {
 	const sections = [];
@@ -1601,7 +1601,7 @@ const extractAstroSources = (sourceText) => {
 	}
 	return sections.join("\n");
 };
-const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script>/gi;
+const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script\b[^>]*>/gi;
 const extractVueScriptContent = (sourceText) => {
 	const scriptBlocks = [];
 	let scriptMatch;
@@ -1609,7 +1609,7 @@ const extractVueScriptContent = (sourceText) => {
 	while ((scriptMatch = VUE_SCRIPT_PATTERN.exec(sourceText)) !== null) if (scriptMatch[1]) scriptBlocks.push(scriptMatch[1]);
 	return scriptBlocks.join("\n");
 };
-const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script\b[^>]*>/gi;
 const extractSvelteScriptContent = (sourceText) => {
 	const scriptBlocks = [];
 	let scriptMatch;
@@ -3846,7 +3846,7 @@ const matchCompiledMapping = (specifier, mappings) => {
 			matchedWildcard = specifier.slice(mapping.prefix.length, specifier.length - mapping.suffix.length);
 		} else if (specifier !== mapping.prefix) continue;
 		for (const target of mapping.targets) {
-			const resolved = resolveAliasTarget(target.replace("*", matchedWildcard));
+			const resolved = resolveAliasTarget(target.replaceAll("*", matchedWildcard));
 			if (resolved) return resolved;
 		}
 	}
@@ -3896,11 +3896,11 @@ const BABEL_CONFIG_GLOBS = [
 ];
 const JEST_CONFIG_GLOBS = ["jest.config.{js,ts,mjs,cjs,json}", "**/jest.config.{js,ts,mjs,cjs,json}"];
 const ALIAS_BLOCK_PATTERN = /alias\s*:\s*\{([\s\S]*?)\}/g;
-const ALIAS_ENTRY_PATTERN = /["']?([@\w$./-]+)["']?\s*:\s*(?:path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)|fileURLToPath\(\s*new URL\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*\)|["']([^"']+)["'])/g;
+const ALIAS_ENTRY_PATTERN = /["']?([@\w$./-]+)["']?\s*:\s*(?:path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["'][\s,]*)+)\)|fileURLToPath\(\s*new URL\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*\)|["']([^"']+)["'])/g;
 const JEST_MODULE_NAME_MAPPER_BLOCK_PATTERN = /moduleNameMapper\s*:\s*\{([\s\S]*?)\}/g;
 const JEST_MODULE_NAME_MAPPER_ENTRY_PATTERN = /["']([^"']+)["']\s*:\s*["']([^"']+)["']/g;
 const WEBPACK_MODULES_BLOCK_PATTERN = /modules\s*:\s*\[([\s\S]*?)\]/g;
-const WEBPACK_PATH_CALL_PATTERN = /path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)/g;
+const WEBPACK_PATH_CALL_PATTERN = /path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["'][\s,]*)+)\)/g;
 const STRING_LITERAL_PATTERN$1 = /["']([^"']+)["']/g;
 const TSCONFIG_FILENAMES = [
 	"tsconfig.json",
@@ -5505,7 +5505,7 @@ const extractBundlerConfigEntryPoints = (directory) => {
 };
 const WEBPACK_ENTRY_BLOCK_PATTERN = /entry\s*:\s*(?:\{[^}]*\}|\[[^\]]*\]|['"][^'"]+['"]|path\.(?:join|resolve)\([^)]*\))/gs;
 const WEBPACK_ENTRY_FILE_PATTERN = /['"]([^'"]+)['"]/g;
-const WEBPACK_PATH_JOIN_PATTERN = /path\.(?:join|resolve)\(\s*__dirname\s*,\s*((?:['"][^'"]*['"]\s*,?\s*)+)\)/g;
+const WEBPACK_PATH_JOIN_PATTERN = /path\.(?:join|resolve)\(\s*__dirname\s*,\s*((?:['"][^'"]*['"][\s,]*)+)\)/g;
 const REQUIRE_RESOLVE_PATTERN = /require\.resolve\(\s*['"]([^'"]+)['"]\s*\)/g;
 const extractWebpackEntryPoints = (directory) => {
 	const entries = [];
@@ -7224,10 +7224,13 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 
 //#endregion
 //#region src/utils/resolve-available-concurrency.ts
+const clampParseConcurrency = (value) => Math.max(1, Math.min(Math.floor(value), 16));
 const resolveAvailableConcurrency = () => {
+	const requestedConcurrency = Number(process.env["DESLOP_PARSE_CONCURRENCY"]);
+	if (Number.isFinite(requestedConcurrency) && requestedConcurrency >= 1) return clampParseConcurrency(requestedConcurrency);
 	const available = node_os.default.availableParallelism();
 	if (!Number.isFinite(available) || available < 1) return 1;
-	return Math.max(1, Math.min(Math.floor(available), 16));
+	return clampParseConcurrency(available);
 };
 
 //#endregion
@@ -12640,21 +12643,23 @@ const generateReport = (graph, config) => {
 	const simplifiableExpressions = config.reportRedundancy ? safeReportDetector("detectSimplifiableExpressions", () => detectSimplifiableExpressions(graph), [], errorSink) : [];
 	const duplicateConstants = config.reportRedundancy ? safeReportDetector("detectDuplicateConstants", () => detectDuplicateConstants(graph), [], errorSink) : [];
 	const crossFileDuplicateExports = config.reportRedundancy ? safeReportDetector("detectCrossFileDuplicateExports", () => detectCrossFileDuplicateExports(graph), [], errorSink) : [];
-	const duplicateBlockResult = safeReportDetector("detectDuplicateBlocks", () => detectDuplicateBlocks(graph, config.duplicateBlocks, config.rootDir), {
+	const emptyDuplicateBlockResult = {
 		duplicateBlocks: [],
 		duplicateBlockClusters: [],
 		shadowedDirectoryPairs: []
-	}, errorSink);
-	const reExportCycles = safeReportDetector("detectReExportCycles", () => detectReExportCycles(graph), [], errorSink);
-	const featureFlags = safeReportDetector("detectFeatureFlags", () => detectFeatureFlags(graph, config.featureFlags), [], errorSink);
-	const complexFunctions = safeReportDetector("detectComplexHotspots", () => detectComplexHotspots(graph, config.complexity), [], errorSink);
-	const privateTypeLeaks = safeReportDetector("detectPrivateTypeLeaks", () => detectPrivateTypeLeaks(graph), [], errorSink);
-	const typeScriptSmellsResult = safeReportDetector("detectTypeScriptSmells", () => detectTypeScriptSmells(graph), {
+	};
+	const duplicateBlockResult = config.reportCodeQuality ? safeReportDetector("detectDuplicateBlocks", () => detectDuplicateBlocks(graph, config.duplicateBlocks, config.rootDir), emptyDuplicateBlockResult, errorSink) : emptyDuplicateBlockResult;
+	const reExportCycles = config.reportCodeQuality ? safeReportDetector("detectReExportCycles", () => detectReExportCycles(graph), [], errorSink) : [];
+	const featureFlags = config.reportCodeQuality ? safeReportDetector("detectFeatureFlags", () => detectFeatureFlags(graph, config.featureFlags), [], errorSink) : [];
+	const complexFunctions = config.reportCodeQuality ? safeReportDetector("detectComplexHotspots", () => detectComplexHotspots(graph, config.complexity), [], errorSink) : [];
+	const privateTypeLeaks = config.reportCodeQuality ? safeReportDetector("detectPrivateTypeLeaks", () => detectPrivateTypeLeaks(graph), [], errorSink) : [];
+	const emptyTypeScriptSmellsResult = {
 		unnecessaryAssertions: [],
 		lazyImportsAtTopLevel: [],
 		commonjsInEsm: [],
 		typeScriptEscapeHatches: []
-	}, errorSink);
+	};
+	const typeScriptSmellsResult = config.reportCodeQuality ? safeReportDetector("detectTypeScriptSmells", () => detectTypeScriptSmells(graph), emptyTypeScriptSmellsResult, errorSink) : emptyTypeScriptSmellsResult;
 	let semanticResult;
 	try {
 		semanticResult = runSemanticAnalysis(graph, config);
@@ -12916,6 +12921,7 @@ const defineConfig = (options) => ({
 	reportTypes: options.reportTypes ?? false,
 	includeEntryExports: options.includeEntryExports ?? false,
 	reportRedundancy: options.reportRedundancy ?? true,
+	reportCodeQuality: options.reportCodeQuality ?? true,
 	semantic: fillSemanticConfig(options.semantic),
 	duplicateBlocks: fillDuplicateBlocksConfig(options.duplicateBlocks),
 	featureFlags: fillFeatureFlagsConfig(options.featureFlags),

package/dist/index.d.cts

@@ -421,6 +421,16 @@ interface DeslopConfig {
   reportTypes: boolean;
   includeEntryExports: boolean;
   reportRedundancy: boolean;
+  /**
+   * Run the non-dead-code "code quality" detectors — duplicate-block (copy-paste)
+   * detection, complexity hotspots, feature flags, TypeScript smells,
+   * private-type leaks, and re-export cycles. On by default. These are by far
+   * the most expensive detectors (duplicate-block detection alone can dominate
+   * a large-repo scan), and they're independent of the dead-code graph findings
+   * (unused files/exports/dependencies, circular dependencies) — so a consumer
+   * that only wants dead-code can set this `false` to skip the bulk of the work.
+   */
+  reportCodeQuality: boolean;
   semantic: SemanticConfig | undefined;
   duplicateBlocks: DuplicateBlocksConfig | undefined;
   featureFlags: FeatureFlagsConfig | undefined;

package/dist/index.d.mts

@@ -421,6 +421,16 @@ interface DeslopConfig {
   reportTypes: boolean;
   includeEntryExports: boolean;
   reportRedundancy: boolean;
+  /**
+   * Run the non-dead-code "code quality" detectors — duplicate-block (copy-paste)
+   * detection, complexity hotspots, feature flags, TypeScript smells,
+   * private-type leaks, and re-export cycles. On by default. These are by far
+   * the most expensive detectors (duplicate-block detection alone can dominate
+   * a large-repo scan), and they're independent of the dead-code graph findings
+   * (unused files/exports/dependencies, circular dependencies) — so a consumer
+   * that only wants dead-code can set this `false` to skip the bulk of the work.
+   */
+  reportCodeQuality: boolean;
   semantic: SemanticConfig | undefined;
   duplicateBlocks: DuplicateBlocksConfig | undefined;
   featureFlags: FeatureFlagsConfig | undefined;

package/dist/index.mjs

@@ -64,8 +64,8 @@ const DEFAULT_EXCLUSIONS = [
 	"**/*.min.mjs",
 	"**/mockServiceWorker.js"
 ];
-const SCRIPT_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|tsc|npx|bun|esr|esno|jiti|babel-node|zx)\s+(?:(?:-[\w-]+(?:[=\s][\w./@=-]+)?\s+)|(?:[\w/-]+\s+))*([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))(?:\s|$)/;
-const SCRIPT_EXTENSIONLESS_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|bun|esr|esno|jiti|babel-node|zx)\s+(?:(?:-[\w-]+(?:[=\s][\w./@=-]+)?\s+))*((?:[./]|[\w@][\w@-]*\/)[\w./@-]+)(?:\s|$)/;
+const SCRIPT_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|tsc|npx|bun|esr|esno|jiti|babel-node|zx)\s+(?:\S+\s+)*?([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))(?:\s|$)/;
+const SCRIPT_EXTENSIONLESS_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|bun|esr|esno|jiti|babel-node|zx)\s+(?:\S+\s+)*?((?:[./]|[\w@][\w@-]*\/)[\w./@-]+)(?:\s|$)/;
 const SCRIPT_CONFIG_FILE_PATTERN = /--config\s+([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))/;
 const SCRIPT_ENTRY_PATTERNS = [];
 const DEFAULT_ENTRY_GLOBS = [
@@ -1550,7 +1550,7 @@ const extractMdxImportsExports = (sourceText) => {
 	return statements.join("\n");
 };
 const ASTRO_FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---/;
-const ASTRO_SCRIPT_TAG_PATTERN = /<script\b([^>]*?)\/>|<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+const ASTRO_SCRIPT_TAG_PATTERN = /<script\b([^>]*?)\/>|<script\b([^>]*)>([\s\S]*?)<\/script\b[^>]*>/gi;
 const ASTRO_SCRIPT_SRC_ATTRIBUTE_PATTERN = /\bsrc\s*=\s*["']([^"']+)["']/i;
 const extractAstroSources = (sourceText) => {
 	const sections = [];
@@ -1569,7 +1569,7 @@ const extractAstroSources = (sourceText) => {
 	}
 	return sections.join("\n");
 };
-const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script>/gi;
+const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script\b[^>]*>/gi;
 const extractVueScriptContent = (sourceText) => {
 	const scriptBlocks = [];
 	let scriptMatch;
@@ -1577,7 +1577,7 @@ const extractVueScriptContent = (sourceText) => {
 	while ((scriptMatch = VUE_SCRIPT_PATTERN.exec(sourceText)) !== null) if (scriptMatch[1]) scriptBlocks.push(scriptMatch[1]);
 	return scriptBlocks.join("\n");
 };
-const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script\b[^>]*>/gi;
 const extractSvelteScriptContent = (sourceText) => {
 	const scriptBlocks = [];
 	let scriptMatch;
@@ -3814,7 +3814,7 @@ const matchCompiledMapping = (specifier, mappings) => {
 			matchedWildcard = specifier.slice(mapping.prefix.length, specifier.length - mapping.suffix.length);
 		} else if (specifier !== mapping.prefix) continue;
 		for (const target of mapping.targets) {
-			const resolved = resolveAliasTarget(target.replace("*", matchedWildcard));
+			const resolved = resolveAliasTarget(target.replaceAll("*", matchedWildcard));
 			if (resolved) return resolved;
 		}
 	}
@@ -3864,11 +3864,11 @@ const BABEL_CONFIG_GLOBS = [
 ];
 const JEST_CONFIG_GLOBS = ["jest.config.{js,ts,mjs,cjs,json}", "**/jest.config.{js,ts,mjs,cjs,json}"];
 const ALIAS_BLOCK_PATTERN = /alias\s*:\s*\{([\s\S]*?)\}/g;
-const ALIAS_ENTRY_PATTERN = /["']?([@\w$./-]+)["']?\s*:\s*(?:path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)|fileURLToPath\(\s*new URL\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*\)|["']([^"']+)["'])/g;
+const ALIAS_ENTRY_PATTERN = /["']?([@\w$./-]+)["']?\s*:\s*(?:path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["'][\s,]*)+)\)|fileURLToPath\(\s*new URL\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*\)|["']([^"']+)["'])/g;
 const JEST_MODULE_NAME_MAPPER_BLOCK_PATTERN = /moduleNameMapper\s*:\s*\{([\s\S]*?)\}/g;
 const JEST_MODULE_NAME_MAPPER_ENTRY_PATTERN = /["']([^"']+)["']\s*:\s*["']([^"']+)["']/g;
 const WEBPACK_MODULES_BLOCK_PATTERN = /modules\s*:\s*\[([\s\S]*?)\]/g;
-const WEBPACK_PATH_CALL_PATTERN = /path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)/g;
+const WEBPACK_PATH_CALL_PATTERN = /path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["'][\s,]*)+)\)/g;
 const STRING_LITERAL_PATTERN$1 = /["']([^"']+)["']/g;
 const TSCONFIG_FILENAMES = [
 	"tsconfig.json",
@@ -5473,7 +5473,7 @@ const extractBundlerConfigEntryPoints = (directory) => {
 };
 const WEBPACK_ENTRY_BLOCK_PATTERN = /entry\s*:\s*(?:\{[^}]*\}|\[[^\]]*\]|['"][^'"]+['"]|path\.(?:join|resolve)\([^)]*\))/gs;
 const WEBPACK_ENTRY_FILE_PATTERN = /['"]([^'"]+)['"]/g;
-const WEBPACK_PATH_JOIN_PATTERN = /path\.(?:join|resolve)\(\s*__dirname\s*,\s*((?:['"][^'"]*['"]\s*,?\s*)+)\)/g;
+const WEBPACK_PATH_JOIN_PATTERN = /path\.(?:join|resolve)\(\s*__dirname\s*,\s*((?:['"][^'"]*['"][\s,]*)+)\)/g;
 const REQUIRE_RESOLVE_PATTERN = /require\.resolve\(\s*['"]([^'"]+)['"]\s*\)/g;
 const extractWebpackEntryPoints = (directory) => {
 	const entries = [];
@@ -7192,10 +7192,13 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 
 //#endregion
 //#region src/utils/resolve-available-concurrency.ts
+const clampParseConcurrency = (value) => Math.max(1, Math.min(Math.floor(value), 16));
 const resolveAvailableConcurrency = () => {
+	const requestedConcurrency = Number(process.env["DESLOP_PARSE_CONCURRENCY"]);
+	if (Number.isFinite(requestedConcurrency) && requestedConcurrency >= 1) return clampParseConcurrency(requestedConcurrency);
 	const available = os.availableParallelism();
 	if (!Number.isFinite(available) || available < 1) return 1;
-	return Math.max(1, Math.min(Math.floor(available), 16));
+	return clampParseConcurrency(available);
 };
 
 //#endregion
@@ -12608,21 +12611,23 @@ const generateReport = (graph, config) => {
 	const simplifiableExpressions = config.reportRedundancy ? safeReportDetector("detectSimplifiableExpressions", () => detectSimplifiableExpressions(graph), [], errorSink) : [];
 	const duplicateConstants = config.reportRedundancy ? safeReportDetector("detectDuplicateConstants", () => detectDuplicateConstants(graph), [], errorSink) : [];
 	const crossFileDuplicateExports = config.reportRedundancy ? safeReportDetector("detectCrossFileDuplicateExports", () => detectCrossFileDuplicateExports(graph), [], errorSink) : [];
-	const duplicateBlockResult = safeReportDetector("detectDuplicateBlocks", () => detectDuplicateBlocks(graph, config.duplicateBlocks, config.rootDir), {
+	const emptyDuplicateBlockResult = {
 		duplicateBlocks: [],
 		duplicateBlockClusters: [],
 		shadowedDirectoryPairs: []
-	}, errorSink);
-	const reExportCycles = safeReportDetector("detectReExportCycles", () => detectReExportCycles(graph), [], errorSink);
-	const featureFlags = safeReportDetector("detectFeatureFlags", () => detectFeatureFlags(graph, config.featureFlags), [], errorSink);
-	const complexFunctions = safeReportDetector("detectComplexHotspots", () => detectComplexHotspots(graph, config.complexity), [], errorSink);
-	const privateTypeLeaks = safeReportDetector("detectPrivateTypeLeaks", () => detectPrivateTypeLeaks(graph), [], errorSink);
-	const typeScriptSmellsResult = safeReportDetector("detectTypeScriptSmells", () => detectTypeScriptSmells(graph), {
+	};
+	const duplicateBlockResult = config.reportCodeQuality ? safeReportDetector("detectDuplicateBlocks", () => detectDuplicateBlocks(graph, config.duplicateBlocks, config.rootDir), emptyDuplicateBlockResult, errorSink) : emptyDuplicateBlockResult;
+	const reExportCycles = config.reportCodeQuality ? safeReportDetector("detectReExportCycles", () => detectReExportCycles(graph), [], errorSink) : [];
+	const featureFlags = config.reportCodeQuality ? safeReportDetector("detectFeatureFlags", () => detectFeatureFlags(graph, config.featureFlags), [], errorSink) : [];
+	const complexFunctions = config.reportCodeQuality ? safeReportDetector("detectComplexHotspots", () => detectComplexHotspots(graph, config.complexity), [], errorSink) : [];
+	const privateTypeLeaks = config.reportCodeQuality ? safeReportDetector("detectPrivateTypeLeaks", () => detectPrivateTypeLeaks(graph), [], errorSink) : [];
+	const emptyTypeScriptSmellsResult = {
 		unnecessaryAssertions: [],
 		lazyImportsAtTopLevel: [],
 		commonjsInEsm: [],
 		typeScriptEscapeHatches: []
-	}, errorSink);
+	};
+	const typeScriptSmellsResult = config.reportCodeQuality ? safeReportDetector("detectTypeScriptSmells", () => detectTypeScriptSmells(graph), emptyTypeScriptSmellsResult, errorSink) : emptyTypeScriptSmellsResult;
 	let semanticResult;
 	try {
 		semanticResult = runSemanticAnalysis(graph, config);
@@ -12884,6 +12889,7 @@ const defineConfig = (options) => ({
 	reportTypes: options.reportTypes ?? false,
 	includeEntryExports: options.includeEntryExports ?? false,
 	reportRedundancy: options.reportRedundancy ?? true,
+	reportCodeQuality: options.reportCodeQuality ?? true,
 	semantic: fillSemanticConfig(options.semantic),
 	duplicateBlocks: fillDuplicateBlocksConfig(options.duplicateBlocks),
 	featureFlags: fillFeatureFlagsConfig(options.featureFlags),

package/dist/parse-worker.mjs

@@ -1234,7 +1234,7 @@ const extractMdxImportsExports = (sourceText) => {
 	return statements.join("\n");
 };
 const ASTRO_FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---/;
-const ASTRO_SCRIPT_TAG_PATTERN = /<script\b([^>]*?)\/>|<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+const ASTRO_SCRIPT_TAG_PATTERN = /<script\b([^>]*?)\/>|<script\b([^>]*)>([\s\S]*?)<\/script\b[^>]*>/gi;
 const ASTRO_SCRIPT_SRC_ATTRIBUTE_PATTERN = /\bsrc\s*=\s*["']([^"']+)["']/i;
 const extractAstroSources = (sourceText) => {
 	const sections = [];
@@ -1253,7 +1253,7 @@ const extractAstroSources = (sourceText) => {
 	}
 	return sections.join("\n");
 };
-const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script>/gi;
+const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script\b[^>]*>/gi;
 const extractVueScriptContent = (sourceText) => {
 	const scriptBlocks = [];
 	let scriptMatch;
@@ -1261,7 +1261,7 @@ const extractVueScriptContent = (sourceText) => {
 	while ((scriptMatch = VUE_SCRIPT_PATTERN.exec(sourceText)) !== null) if (scriptMatch[1]) scriptBlocks.push(scriptMatch[1]);
 	return scriptBlocks.join("\n");
 };
-const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script\b[^>]*>/gi;
 const extractSvelteScriptContent = (sourceText) => {
 	const scriptBlocks = [];
 	let scriptMatch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deslop-js",
-  "version": "0.0.25",
+  "version": "0.5.8",
   "description": "Deslop JavaScript code",
   "keywords": [
     "dead-code",
@@ -12,9 +12,9 @@
     "typescript",
     "unused"
   ],
-  "homepage": "https://github.com/millionco/deslop-js#readme",
+  "homepage": "https://github.com/millionco/react-doctor#readme",
   "bugs": {
-    "url": "https://github.com/millionco/deslop-js/issues"
+    "url": "https://github.com/millionco/react-doctor/issues"
   },
   "license": "MIT",
   "author": {
@@ -23,7 +23,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/millionco/deslop-js.git",
+    "url": "https://github.com/millionco/react-doctor.git",
     "directory": "packages/deslop-js"
   },
   "files": [