cve-lite-cli 1.0.3 → 1.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,6 +1,23 @@
1
- # CVE Lite CLI
1
+ <div align="center">
2
+ <img src="https://github.com/sonukapoor/cve-lite-cli/blob/main/assets/logo-with-title.png" alt="CVE Lite CLI" width="320"/>
2
3
 
3
- Fast, developer-friendly vulnerability scanning for JavaScript and TypeScript projects.
4
+ <h1>CVE Lite CLI</h1>
5
+ <p>Fast, developer-friendly vulnerability scanning for JavaScript and TypeScript projects.</p>
6
+
7
+ <strong>Scan. Prioritize. Fix.</strong>
8
+
9
+ <p>
10
+ <a href="#quick-start">Quick Start</a> •
11
+ <a href="#features">Features</a> •
12
+ <a href="#usage">Usage</a> •
13
+ <a href="CONTRIBUTING.md">Contributing</a>
14
+ </p>
15
+
16
+ </div>
17
+
18
+ ---
19
+
20
+ ## What is CVE Lite CLI
4
21
 
5
22
  **CVE Lite CLI** helps developers scan their projects for known package vulnerabilities without signing up for an expensive platform. It is built for the moment right before release, when you want a clear answer, a practical fix plan, and a tool you can actually afford to use.
6
23
 
@@ -24,7 +41,7 @@ Or run it one-off with `npx`:
24
41
  npx cve-lite-cli /path/to/project
25
42
  ```
26
43
 
27
- Common examples:
44
+ ## Usage
28
45
 
29
46
  ```bash
30
47
  # Basic scan
@@ -36,6 +53,10 @@ cve-lite /path/to/project --all
36
53
  # Focus only on urgent findings
37
54
  cve-lite /path/to/project --min-severity high
38
55
 
56
+ # Show full detailed output, fix plan, paths, and full table
57
+ # Recommended for CI logs when you want full context
58
+ cve-lite /path/to/project --verbose
59
+
39
60
  # Fail a build on high severity and above
40
61
  cve-lite /path/to/project --fail-on high
41
62
 
@@ -44,19 +65,52 @@ cve-lite /path/to/project --json
44
65
 
45
66
  # SARIF output
46
67
  cve-lite /path/to/project --sarif --output reports/scan.sarif
68
+
69
+ # Use a custom advisory endpoint
70
+ cve-lite /path/to/project --osv-url https://security.company.internal/osv
47
71
  ```
48
72
 
49
73
  ## What it looks like
50
74
 
51
- Below is a real example of the console experience. In a terminal, the severity labels, summaries, and section headers are colorized for readability.
75
+ CVE Lite CLI produces a clean, summary-first console view by default, designed for fast triage before release.
52
76
 
53
- ![Image 1](https://raw.githubusercontent.com/sonukapoor/cve-lite-cli/main/image-1.png)
54
- ![Image 2](https://raw.githubusercontent.com/sonukapoor/cve-lite-cli/main/image-2.png)
77
+ For deeper investigation, running with `--verbose` provides full details, including dependency paths, a complete fix plan, and a detailed table view.
55
78
 
56
79
  That is the core idea: install it, point it at your project, and immediately get a practical fix plan instead of a wall of raw advisories.
57
80
 
58
81
  The final status line also gives the scan a clear ending, which makes terminal use and screenshots easier to read.
59
82
 
83
+ See the example below using OWASP Juice Shop for real output samples.
84
+
85
+ ## Example: Scanning OWASP Juice Shop (Real Output)
86
+
87
+ CVE Lite CLI can be used against real-world vulnerable applications such as the OWASP Juice Shop.
88
+
89
+ OWASP [Juice Shop](https://github.com/juice-shop/juice-shop) is a deliberately insecure JavaScript application widely used for security training and testing. Running CVE Lite CLI against it provides a realistic example of how the tool behaves on a dependency tree with known vulnerabilities.
90
+
91
+ To try this yourself:
92
+
93
+ Example:
94
+
95
+ ```bash
96
+ git clone https://github.com/juice-shop/juice-shop.git
97
+ cd juice-shop
98
+ cve-lite .
99
+ ```
100
+
101
+ <p align="center">
102
+ <img src="https://github.com/sonukapoor/cve-lite-cli/blob/main/assets/default-output.png" alt="CVE Lite CLI default output screenshot" width="900"/>
103
+ </p>
104
+
105
+ Verbose examples:
106
+
107
+ <p align="center">
108
+ <img src="https://github.com/sonukapoor/cve-lite-cli/blob/main/assets/verbose-output-1.png" alt="CVE Lite CLI verbose output screenshot" width="900"/>
109
+ <img src="https://github.com/sonukapoor/cve-lite-cli/blob/main/assets/verbose-output-2.png" alt="CVE Lite CLI verbose output screenshot" width="900"/>
110
+ <img src="https://github.com/sonukapoor/cve-lite-cli/blob/main/assets/verbose-output-3.png" alt="CVE Lite CLI verbose output screenshot" width="900"/>
111
+ <img src="https://github.com/sonukapoor/cve-lite-cli/blob/main/assets/verbose-output-4.png" alt="CVE Lite CLI verbose output screenshot" width="900"/>
112
+ </p>
113
+
60
114
  ## Why this tool exists
61
115
 
62
116
  A lot of developers want a practical dependency scan right before release, but they do not want the cost, complexity, or friction of a larger platform just to answer a simple question:
@@ -85,6 +139,7 @@ The project emphasizes:
85
139
  - direct vs transitive visibility
86
140
  - top-priority fixes and a suggested remediation plan
87
141
  - JSON and SARIF output for automation
142
+ - configurable advisory endpoint support via `--osv-url` for internal proxies or mirrors
88
143
  - a small, reviewable runtime footprint
89
144
 
90
145
  That narrow scope is deliberate. CVE Lite CLI is not trying to be a full application security platform or a broad multi-surface scanner. It is trying to be a lightweight, understandable, developer-first tool for teams that want practical vulnerability scanning without extra cost or complexity.
@@ -103,43 +158,56 @@ Its role is narrower and workflow-focused:
103
158
 
104
159
  This section is here to make the scope clear. CVE Lite CLI aims to complement the broader security ecosystem by being a practical, low-friction option for JS/TS dependency checks close to release time.
105
160
 
161
+ ## Network behavior and privacy
162
+
163
+ CVE Lite CLI is a local-first scanner. It parses dependency information locally, uses local caching to reduce repeated lookups, and in standard mode queries OSV for advisory data needed for matching.
164
+
165
+ It does not require a hosted account, cloud dashboard, or source code upload.
166
+
167
+ For the full explanation, see [Network Behavior and Privacy](./docs/network-and-privacy.md).
168
+
169
+ ### Planned support for stricter environments
170
+
171
+ Support for stricter network-controlled environments is planned on the roadmap, including:
172
+
173
+ - offline scanning mode with zero outbound calls
174
+ - custom advisory endpoint support for internal mirrors or proxies
175
+ - local advisory database input for controlled or air-gapped workflows
176
+
106
177
  ## How it works
107
178
 
108
- CVE Lite CLI follows a simple workflow:
179
+ ### Architectural Philosophy
180
+ CVE Lite CLI is designed as a **local-first, metadata-only** scanner. Unlike traditional SaaS security platforms that require code uploads or heavy agent installations, this tool operates directly within the developer's environment. It focuses on the "moment of release"—providing a high-speed, low-noise assessment of the dependency tree by analyzing resolved versions in project lockfiles.
109
181
 
110
- 1. Read a supported lockfile from your project.
111
- 2. Resolve package names and versions locally.
112
- 3. Match those packages against OSV advisory data.
113
- 4. Classify findings as direct or transitive where possible.
114
- 5. Highlight the most important fixes first.
115
- 6. Produce terminal, JSON, or SARIF output.
182
+ <p align="center">
183
+ <img src="https://github.com/sonukapoor/cve-lite-cli/blob/main/assets/diagram.png" alt="CVE Lite CLI Workflow" width="800"/>
184
+ </p>
116
185
 
117
- The goal is to keep vulnerability scanning practical, understandable, and easy to act on.
186
+ ### Workflow Specifications
187
+ * **Trust Boundary & Privacy:** The scan is non-intrusive. Only package names and exact versions are extracted. No source code, environment variables, or proprietary logic is ever transmitted to the external OSV (Open Source Vulnerability) API.
188
+ * **Lockfile-Driven Accuracy:** By parsing `package-lock.json`, `pnpm-lock.yaml`, or `yarn.lock`, the tool avoids the "it works on my machine" discrepancy. It scans the *exact* dependency tree that will be deployed.
189
+ * **Intelligent Triage:** The Analysis engine utilizes the lockfile's graph structure to distinguish between dependencies you manage directly and those brought in by third-party packages (transitive). This allows for a "Fix the Root" strategy rather than chasing individual nested vulnerabilities.
190
+ * **Performance Optimization:** A local TTL (Time-To-Live) cache stores advisory results. This ensures that subsequent scans—common in iterative development or CI/CD retry loops—are near-instant and respect external API rate limits.
191
+ * **Standards-Based Output:** Results are natively available in **SARIF (Static Analysis Results Interchange Format)** and **JSON**, ensuring compatibility with modern DevSecOps dashboards and IDE integrations.
118
192
 
119
193
  ## What makes it stand out
120
194
 
121
195
  - **fast, low-friction workflow**
122
196
  Run it locally against a project without adopting a large security platform.
123
-
124
197
  - **practical remediation guidance**
125
198
  It does not stop at raw advisory output. It highlights top-priority fixes and suggests a fix plan.
126
-
127
199
  - **direct vs transitive visibility**
128
200
  The output makes it easier to see whether the risk comes from something you installed directly or from a nested package.
129
-
130
201
  - **developer-first**
131
202
  It is optimized for developers working with npm, pnpm, and Yarn lockfiles.
132
-
133
203
  - **budget-friendly**
134
204
  It is intended for developers and teams who want useful security checks without paying for a large commercial product.
135
-
136
205
  - **local-first**
137
206
  It reads your project locally and uses package/version matching against OSV advisories.
138
-
139
207
  - **release-focused**
140
208
  It is especially useful before a release, in CI, or during final dependency cleanup.
141
209
 
142
- ## Core features
210
+ ## Features
143
211
 
144
212
  ### 1. Lockfile-based scanning
145
213
 
@@ -162,6 +230,8 @@ Instead of only showing advisory IDs, the CLI reports:
162
230
  - advisory IDs
163
231
  - dependency path hints
164
232
 
233
+ By default, the CLI now presents a cleaner summary-first view, with `--verbose` available for the full detailed output.
234
+
165
235
  ### 3. Top priority fixes
166
236
 
167
237
  The CLI highlights the most important issues first, so developers can focus on the findings most likely to matter immediately.
@@ -245,16 +315,18 @@ Run it before a release, during dependency cleanup, or after a major package upg
245
315
 
246
316
  This repository also uses CVE Lite CLI in its own GitHub Actions workflow to scan itself as part of CI. See [`self-scan.yml`](./.github/workflows/self-scan.yml).
247
317
 
318
+ For CI, we recommend using `--verbose` so build logs include the full fix plan, dependency paths, and detailed table output when a scan fails.
319
+
248
320
  Use it as a release gate in CI:
249
321
 
250
322
  ```bash
251
- cve-lite . --fail-on high
323
+ cve-lite . --verbose --fail-on high
252
324
  ```
253
325
 
254
326
  Export SARIF in CI:
255
327
 
256
328
  ```bash
257
- cve-lite . --sarif --output reports/scan.sarif
329
+ cve-lite . --verbose --sarif --output reports/scan.sarif
258
330
  ```
259
331
 
260
332
  ### Scripted automation
@@ -346,20 +418,6 @@ CVE Lite CLI is best for:
346
418
 
347
419
  If your goal is a practical developer-first CVE scan right before release, CVE Lite CLI is designed to be one of the most approachable options in that workflow.
348
420
 
349
- ## Philosophy
350
-
351
- CVE Lite CLI is not trying to be everything.
352
-
353
- It is trying to be **one of the easiest and most useful tools for developers who need a practical CVE scan right now**.
354
-
355
- That means:
356
-
357
- - fast setup
358
- - understandable output
359
- - useful remediation guidance
360
- - low friction
361
- - realistic adoption for developers without enterprise budgets
362
-
363
421
  ## Current limitations
364
422
 
365
423
  To keep the project honest, here is what it does **not** do in the current version:
@@ -376,17 +434,23 @@ CVE Lite CLI is best described as:
376
434
 
377
435
  **A fast, developer-friendly dependency vulnerability scanner for JavaScript and TypeScript projects, built for teams that want actionable results without the cost and complexity of a full security platform.**
378
436
 
379
- ## Roadmap ideas
437
+ ## Roadmap
438
+
439
+ CVE Lite CLI is evolving from a vulnerability scanner into a comprehensive remediation engine.
440
+
441
+ ### Phase 1: Advanced Remediation Intelligence (Short-Term)
442
+ * **Executable Fix-Plan:** Move from suggesting a plan to generating executable commands (e.g., `npm install package@version`) to resolve direct vulnerabilities.
443
+ * **Transitive Parent Mapping:** Enhance output to explicitly map the dependency path from the root to the vulnerable nested package, making manual triage effortless.
444
+ * **Deduplication Analysis:** Identify instances where multiple versions of the same vulnerable package exist and suggest a single version for consolidation.
380
445
 
381
- Planned or possible future improvements include:
446
+ ### Phase 2: Ecosystem & Integration (Mid-Term)
447
+ * **Official GitHub Action:** Create a dedicated Action for one-line setup in CI/CD pipelines.
448
+ * **Expanded Lockfile Support:** Introduce parsers for emerging JS/TS ecosystems, including `bun.lockb`.
449
+ * **IDE Integration:** Develop a lightweight extension to highlight vulnerable packages directly within the code editor.
382
450
 
383
- - richer remediation guidance
384
- - stronger CI examples
385
- - broader export improvements
386
- - improved caching options
387
- - better package grouping and deduplication insights
388
- - publishable npm release polish
389
- - GitHub Action or container workflow support
451
+ ### Phase 3: Maturity & Compliance (Long-Term)
452
+ * **Standardized SBOM Support:** Add the ability to export findings as an **SBOM (Software Bill of Materials)** in CycloneDX or SPDX formats.
453
+ * **Community Plugin System:** Decouple the scanner logic to allow community-contributed data sources and custom security rules.
390
454
 
391
455
  ## Contributing
392
456
 
@@ -0,0 +1 @@
1
+ export {};
@@ -0,0 +1,51 @@
1
+ export class OsvAdvisorySource {
2
+ baseUrl;
3
+ constructor(baseUrl = "https://api.osv.dev") {
4
+ this.baseUrl = baseUrl;
5
+ }
6
+ async queryBatch(packages) {
7
+ try {
8
+ const response = await fetch(`${this.baseUrl}/v1/querybatch`, {
9
+ method: "POST",
10
+ headers: {
11
+ "Content-Type": "application/json",
12
+ },
13
+ body: JSON.stringify({
14
+ queries: packages.map(p => ({
15
+ package: {
16
+ ecosystem: p.ecosystem,
17
+ name: p.name,
18
+ },
19
+ version: p.version,
20
+ })),
21
+ }),
22
+ });
23
+ if (!response.ok) {
24
+ throw new Error(`OSV batch query failed: ${response.status} ${response.statusText}`);
25
+ }
26
+ const data = await response.json();
27
+ return data.results.map((r, i) => ({
28
+ package: packages[i].name,
29
+ version: packages[i].version,
30
+ vulnerabilities: r.vulns || [],
31
+ }));
32
+ }
33
+ catch (error) {
34
+ const message = error instanceof Error ? error.message : String(error);
35
+ throw new Error(`OSV batch query failed for ${this.baseUrl}: ${message}`);
36
+ }
37
+ }
38
+ async getVuln(id) {
39
+ try {
40
+ const response = await fetch(`${this.baseUrl}/v1/vulns/${encodeURIComponent(id)}`);
41
+ if (!response.ok) {
42
+ throw new Error(`OSV vuln fetch failed for ${id}: ${response.status} ${response.statusText}`);
43
+ }
44
+ return response.json();
45
+ }
46
+ catch (error) {
47
+ const message = error instanceof Error ? error.message : String(error);
48
+ throw new Error(`OSV vuln fetch failed for ${id} via ${this.baseUrl}: ${message}`);
49
+ }
50
+ }
51
+ }
package/dist/banner.js ADDED
@@ -0,0 +1,10 @@
1
+ import { chalk } from "./chalk";
2
+ export const CLI_BANNER = [
3
+ `${chalk.green(">_")} ${chalk.bold.whiteBright("CVE Lite CLI")}`,
4
+ chalk.gray("────────────────────────────────"),
5
+ `${chalk.green("✔")} Scan dependencies`,
6
+ `${chalk.green("✔")} Highlight critical issues`,
7
+ `${chalk.green("✔")} Show a clear fix plan`,
8
+ "",
9
+ chalk.gray("Fast. Local. Developer-first.")
10
+ ].join("\n");
package/dist/chalk.js ADDED
@@ -0,0 +1,44 @@
1
+ import process from "node:process";
2
+ const ansi = {
3
+ reset: "\x1b[0m",
4
+ bold: "\x1b[1m",
5
+ red: "\x1b[31m",
6
+ redBright: "\x1b[91m",
7
+ green: "\x1b[32m",
8
+ greenBright: "\x1b[92m",
9
+ yellow: "\x1b[33m",
10
+ blue: "\x1b[34m",
11
+ blueBright: "\x1b[94m",
12
+ magenta: "\x1b[35m",
13
+ cyan: "\x1b[36m",
14
+ white: "\x1b[37m",
15
+ whiteBright: "\x1b[97m",
16
+ gray: "\x1b[90m"
17
+ };
18
+ const colorEnabled = Boolean(process.stdout.isTTY) && process.env.NO_COLOR !== "1";
19
+ function paint(code, text) {
20
+ if (!colorEnabled)
21
+ return text;
22
+ return `${code}${text}${ansi.reset}`;
23
+ }
24
+ export const chalk = {
25
+ bold: Object.assign((text) => paint(ansi.bold, text), {
26
+ cyan: (text) => paint(ansi.bold + ansi.cyan, text),
27
+ green: (text) => paint(ansi.bold + ansi.green, text),
28
+ magenta: (text) => paint(ansi.bold + ansi.magenta, text),
29
+ blue: (text) => paint(ansi.bold + ansi.blue, text),
30
+ yellow: (text) => paint(ansi.bold + ansi.yellow, text)
31
+ }),
32
+ cyan: (text) => paint(ansi.cyan, text),
33
+ green: (text) => paint(ansi.green, text),
34
+ greenBright: (text) => paint(ansi.greenBright, text),
35
+ red: (text) => paint(ansi.red, text),
36
+ redBright: (text) => paint(ansi.redBright, text),
37
+ yellow: (text) => paint(ansi.yellow, text),
38
+ blue: (text) => paint(ansi.blue, text),
39
+ blueBright: (text) => paint(ansi.blueBright, text),
40
+ magenta: (text) => paint(ansi.magenta, text),
41
+ gray: (text) => paint(ansi.gray, text),
42
+ white: (text) => paint(ansi.white, text),
43
+ whiteBright: (text) => paint(ansi.whiteBright, text)
44
+ };
@@ -0,0 +1,92 @@
1
+ export function parseArgs(argv) {
2
+ const options = {
3
+ failOn: "critical",
4
+ batchSize: "100",
5
+ searchDepth: "4",
6
+ minSeverity: "medium"
7
+ };
8
+ let projectArg;
9
+ for (let i = 0; i < argv.length; i++) {
10
+ const arg = argv[i];
11
+ if (arg === "-h" || arg === "--help") {
12
+ options.help = true;
13
+ continue;
14
+ }
15
+ if (arg === "--json") {
16
+ options.json = true;
17
+ continue;
18
+ }
19
+ if (arg === "--verbose") {
20
+ options.verbose = true;
21
+ continue;
22
+ }
23
+ if (arg === "--prod-only") {
24
+ options.prodOnly = true;
25
+ continue;
26
+ }
27
+ if (arg === "--offline") {
28
+ options.offline = true;
29
+ continue;
30
+ }
31
+ if (arg === "--all") {
32
+ options.all = true;
33
+ continue;
34
+ }
35
+ if (arg === "--fail-on") {
36
+ options.failOn = argv[++i] ?? options.failOn;
37
+ continue;
38
+ }
39
+ if (arg.startsWith("--fail-on=")) {
40
+ options.failOn = arg.slice("--fail-on=".length);
41
+ continue;
42
+ }
43
+ if (arg === "--batch-size") {
44
+ options.batchSize = argv[++i] ?? options.batchSize;
45
+ continue;
46
+ }
47
+ if (arg.startsWith("--batch-size=")) {
48
+ options.batchSize = arg.slice("--batch-size=".length);
49
+ continue;
50
+ }
51
+ if (arg === "--cache-dir") {
52
+ options.cacheDir = argv[++i];
53
+ continue;
54
+ }
55
+ if (arg.startsWith("--cache-dir=")) {
56
+ options.cacheDir = arg.slice("--cache-dir=".length);
57
+ continue;
58
+ }
59
+ if (arg === "--osv-url") {
60
+ options.osvUrl = argv[++i];
61
+ continue;
62
+ }
63
+ if (arg.startsWith("--osv-url=")) {
64
+ options.osvUrl = arg.slice("--osv-url=".length);
65
+ continue;
66
+ }
67
+ if (arg === "--search-depth") {
68
+ options.searchDepth = argv[++i] ?? options.searchDepth;
69
+ continue;
70
+ }
71
+ if (arg.startsWith("--search-depth=")) {
72
+ options.searchDepth = arg.slice("--search-depth=".length);
73
+ continue;
74
+ }
75
+ if (arg === "--min-severity") {
76
+ options.minSeverity = argv[++i] ?? options.minSeverity;
77
+ continue;
78
+ }
79
+ if (arg.startsWith("--min-severity=")) {
80
+ options.minSeverity = arg.slice("--min-severity=".length);
81
+ continue;
82
+ }
83
+ if (arg.startsWith("-"))
84
+ throw new Error(`Unknown option: ${arg}`);
85
+ if (!projectArg) {
86
+ projectArg = arg;
87
+ continue;
88
+ }
89
+ throw new Error(`Unexpected argument: ${arg}`);
90
+ }
91
+ return { options, projectArg };
92
+ }
@@ -0,0 +1,42 @@
1
+ import { chalk } from "../utils/chalk.js";
2
+ const CLI_BANNER = [
3
+ `${chalk.green(">_")} ${chalk.bold.whiteBright("CVE Lite CLI")}`,
4
+ chalk.gray("────────────────────────────────"),
5
+ `${chalk.green("✔")} Scan dependencies`,
6
+ `${chalk.green("✔")} Highlight critical issues`,
7
+ `${chalk.green("✔")} Show a clear fix plan`,
8
+ "",
9
+ chalk.gray("Fast. Local. Developer-first.")
10
+ ].join("\n");
11
+ export function printBanner(options) {
12
+ if (options?.json)
13
+ return;
14
+ console.log(CLI_BANNER);
15
+ console.log("");
16
+ }
17
+ export function printHelp() {
18
+ printBanner();
19
+ const lines = [
20
+ "cve-lite",
21
+ "",
22
+ "Fast local-first CVE scanner for JS/TS projects using lockfiles + OSV",
23
+ "",
24
+ "Usage:",
25
+ " cve-lite [projectPath] [options]",
26
+ "",
27
+ "Options:",
28
+ " --json Print JSON output",
29
+ " --osv-url <url> Use a custom OSV-compatible advisory endpoint",
30
+ " --verbose Show detailed output with fix plan, paths, and full table",
31
+ " --prod-only Exclude dev dependencies where available",
32
+ " --fail-on <severity> Exit non-zero at or above severity (default: critical)",
33
+ " --batch-size <number> OSV batch size (default: 100)",
34
+ " --offline Use cached vulnerability details only",
35
+ " --cache-dir <path> Override cache directory",
36
+ " --search-depth <number> Recursive search depth (default: 4)",
37
+ " --all Show all findings in the main table",
38
+ " --min-severity <level> Minimum severity shown in table (default: medium)",
39
+ " -h, --help Show this help message"
40
+ ];
41
+ console.log(lines.join("\n"));
42
+ }
@@ -0,0 +1,19 @@
1
+ export const severityOrder = {
2
+ none: 0,
3
+ low: 1,
4
+ medium: 2,
5
+ high: 3,
6
+ critical: 4,
7
+ unknown: 1
8
+ };
9
+ export const EXCLUDED_DIRS = new Set([
10
+ ".git",
11
+ "node_modules",
12
+ "dist",
13
+ "build",
14
+ "coverage",
15
+ ".next",
16
+ ".turbo",
17
+ ".angular",
18
+ ".nx"
19
+ ]);