clone-alert 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ruslan Baryshev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,243 @@
+# clone-alert
+
+> Fast **copy‑paste detector** for **TypeScript**, **JavaScript**, **JSX/TSX**, **Vue**, **Svelte** and **Angular** — a **PMD CPD‑compatible** duplicate‑code finder you can drop into any project or CI pipeline.
+
+[![npm version](https://img.shields.io/npm/v/clone-alert.svg)](https://www.npmjs.com/package/clone-alert)
+[![license](https://img.shields.io/npm/l/clone-alert.svg)](./LICENSE)
+[![node](https://img.shields.io/node/v/clone-alert.svg)](https://nodejs.org)
+[![types](https://img.shields.io/npm/types/clone-alert.svg)](https://www.npmjs.com/package/clone-alert)
+
+**clone-alert** finds duplicated and copy‑pasted code across your codebase by comparing **token streams** — the same proven approach as [PMD CPD](https://pmd.github.io/) (Copy‑Paste Detector), but built natively for the JavaScript/TypeScript ecosystem and your frontend templates. Catch code clones, enforce **DRY**, reduce technical debt, and fail your build when duplication creeps in.
+
+```sh
+npx clone-alert --minimum-tokens 50 --files src
+```
+
+---
+
+## Why clone-alert?
+
+- 🎯 **PMD CPD‑compatible** — a faithful port of PMD's match algorithm and JavaScript/TypeScript tokenizers, validated against PMD's own golden fixtures.
+- ⚡ **Fast on large monorepos** — a struct‑of‑arrays token core with a Karp–Rabin rolling hash and radix‑sorted buckets. In our [benchmarks](#benchmarks) it runs **10–30× faster** than PMD CPD while using **1.4–2.5× less memory**, on real codebases from Next.js to nx.
+- 🧩 **Frontend templates, natively** — tokenizes **Vue** `<template>`, **Svelte** markup, and **Angular** templates, not just `<script>` blocks. Detects template‑to‑script duplication too.
+- 🧪 **Zero‑config CLI** — sensible defaults, recursive directory scan, `node_modules`/`.git`/`dist` skipped automatically.
+- 📦 **Tiny footprint** — a single runtime dependency (`typescript`). Framework parsers are **optional peer dependencies**, loaded only when needed.
+- 🛠 **CI‑ready** — `text`, `json`, and PMD‑style `xml` reports, plus `--fail-on-violation` (exit code `4`).
+- 🔇 **Inline suppression** — ignore known duplication with `CPD-OFF` / `CPD-ON` comment markers.
+
+## Supported languages & frameworks
+
+| Language / framework | Extensions | Notes |
+| --- | --- | --- |
+| TypeScript | `.ts`, `.mts`, `.cts` | PMD `typescript` token granularity by default |
+| TSX / JSX | `.tsx`, `.jsx` | React‑style components |
+| JavaScript | `.js`, `.mjs`, `.cjs` | Native scanner tokenization |
+| Vue | `.vue` | `<script>`, `<script setup>` and `<template>` markup |
+| Svelte | `.svelte` | `<script>` and markup (**requires Svelte 5+**) |
+| Angular | `.html`, `.htm`, inline templates | External and `@Component` inline templates |
+
+## Installation
+
+Add it as a dev dependency:
+
+```sh
+npm install --save-dev clone-alert
+# or
+pnpm add -D clone-alert
+# or
+yarn add -D clone-alert
+```
+
+Or run it once, without installing:
+
+```sh
+npx clone-alert --minimum-tokens 50 --files src
+```
+
+Requires **Node.js 18+**.
+
+## Quick start
+
+```sh
+# Scan a folder and print a human‑readable report
+clone-alert --minimum-tokens 50 --files src
+
+# Fail CI when duplication is found (exit code 4)
+clone-alert --minimum-tokens 50 --files src --fail-on-violation
+
+# Machine‑readable output for dashboards
+clone-alert --format json --files src,packages > duplication.json
+```
+
+## Usage
+
+```sh
+clone-alert [options] [<path>...]
+```
+
+### CLI options
+
+| Option | Description |
+| --- | --- |
+| `--files <path[,path...]>` | Files or directories to scan. Can be repeated. |
+| `--minimum-tokens <n>` | Minimum duplicated token span. Default: `50`. |
+| `--minimum-tile-size <n>` | Alias for `--minimum-tokens`. |
+| `--format <text\|xml\|json>` | Report format. Default: `text`. |
+| `--extensions <ext[,ext...]>` | Extensions to include during recursive scans. |
+| `--exclude <glob[,glob...]>` | Exclude files or directories (glob). Can be repeated. |
+| `--ignore-identifiers` / `--no-ignore-identifiers` | Normalize or compare identifier names. Strict by default, like PMD. |
+| `--ignore-literals` / `--no-ignore-literals` | Normalize or compare literals. Strict by default, like PMD. |
+| `--pmd-typescript-compatibility` / `--no-…` | Match PMD `typescript` granularity for `.ts/.tsx` (split template literals into atoms, collapse regexp). On by default. |
+| `--svelte-templates` / `--no-svelte-templates` | Tokenize `.svelte` markup, not just `<script>`. On by default. |
+| `--vue-templates` / `--no-vue-templates` | Tokenize `.vue` markup, not just `<script>`. On by default. |
+| `--angular-inline-templates` | Also scan Angular `@Component` inline templates. |
+| `--skip-angular-inline-templates` | Do not scan inline Angular templates (explicit default). |
+| `--fail-on-violation` | Exit with code `4` when duplications are found. |
+| `-h, --help` | Show help. |
+| `-V, --version` | Show version. |
+
+Default extensions:
+
+```text
+.ts  .tsx  .js  .jsx  .mts  .cts  .mjs  .cjs  .vue  .svelte  .html  .htm
+```
+
+### Examples
+
+```sh
+# Strict, PMD‑like scan of a source tree, fail the build on any clone
+clone-alert --minimum-tokens 30 --files src --fail-on-violation
+
+# PMD‑style XML report across several paths
+clone-alert --minimum-tokens 50 --format xml src test
+
+# JSON report for a monorepo, excluding generated code
+clone-alert --format json --files src,packages --exclude '**/generated/**'
+
+# Find renamed clones by normalizing identifiers and literals
+clone-alert --minimum-tokens 40 --ignore-identifiers --ignore-literals --files src
+```
+
+## PMD CPD compatibility
+
+clone-alert targets PMD CPD‑style duplicate detection for the JavaScript/TypeScript ecosystem: `.js`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.jsx`, plus the frontend templates typical of TS projects. Verified compatibility currently covers:
+
+- PMD JavaScript/TypeScript CPD tokenizer fixtures (vendored, so tests need no PMD checkout).
+- The token‑based duplicate search, including `--ignore-identifiers`, `--ignore-literals`, and `CPD-OFF` / `CPD-ON` suppression markers.
+- JSX/TSX tokenization and clone detection for React‑style components.
+- Real npm layouts: `src/**/*.ts`, `src/**/*.tsx`, monorepo `packages/**`, and excluding generated files via `--exclude`.
+- `text`, `json`, and `xml` reports: occurrence order, token counts, line ranges, and paths.
+
+PMD compatibility mode is on by default: JS operators absent from PMD's ES5 JavaCC grammar are split into the same token stream (e.g. `=>` → `=` and `>`, `...` → `.` `.` `.`), and regexp literals collapse to a single token, just like PMD.
+
+> **Note:** `--ignore-identifiers` in clone-alert really does normalize JS identifiers. In PMD's `ecmascript` lexer the same flag barely changes the token stream, so for a strict PMD‑JS comparison, leave it off.
+
+## Frontend templates
+
+For `.vue`, `.svelte`, and Angular HTML, clone-alert uses the optional peer packages `@vue/compiler-sfc`, `svelte`, and `@angular/compiler`. If a package isn't installed, matching files are skipped with a warning.
+
+- **Vue** — binding and interpolation expressions (`{{ }}`, `:prop`, `v-if`, `@event`) are tokenized as TypeScript in the component scope, so a duplicated expression across `<template>` and `<script setup>` is caught too.
+- **Svelte** — markup tokenization requires **Svelte 5+** (it relies on the modern `ast.fragment` AST). On Svelte 3/4 only `<script>` is scanned, silently and without errors.
+- **Angular** — inline templates are **off by default** to keep TypeScript mode closer to PMD CPD. Enable `--angular-inline-templates` to scan them as a clone-alert extension.
+
+Markup and code often want different thresholds (markup is noisy at a low `--minimum-tokens`), so the template layers sit behind toggles. Run two passes for the best of both:
+
+```sh
+# Code at a low threshold, markup at a high one (two runs)
+clone-alert --minimum-tokens 40 --no-svelte-templates --files src
+clone-alert --minimum-tokens 150 --files src
+```
+
+## Suppressing duplication
+
+Wrap intentional or generated duplication in `CPD-OFF` / `CPD-ON` comments and it won't be reported:
+
+```ts
+// CPD-OFF
+const generatedTableA = { /* ... */ };
+const generatedTableB = { /* ... */ };
+// CPD-ON
+```
+
+## Programmatic API
+
+clone-alert ships with TypeScript types and a small Node API:
+
+```ts
+import { Cpd } from 'clone-alert';
+
+const cpd = new Cpd({ minTileSize: 50 });
+cpd.addPath('src/a.ts');
+cpd.addPath('src/b.ts');
+
+const matches = cpd.run();
+console.log(cpd.report(matches));
+```
+
+## How it works
+
+1. Each file is tokenized into a flat stream of lexical tokens (TypeScript scanner for code; framework compilers for Vue/Svelte/Angular markup).
+2. Tokens are interned into a compact struct‑of‑arrays store backed by typed arrays.
+3. A Karp–Rabin rolling hash plus a stable radix sort group candidate windows, and a PMD‑style collector reports the longest non‑overlapping matches.
+
+Framework template tokens live in a separate namespace from script tokens, so markup never cross‑matches code by accident — while shared‑language expressions still do.
+
+## Benchmarks
+
+clone-alert is a drop-in for PMD CPD that runs **10–30× faster** on **1.4–2.5× less memory** — on the same files, finding the same clones.
+
+Measured with [`npm run compare:pmd`](#development) on five real-world TypeScript codebases. Only pure `.ts` is compared (the exact file set PMD's `typescript` lexer can parse), so all tools see byte-identical input. macOS, Node 20, `--minimum-tokens 50`, JVM start-up counted for PMD as in real CLI use:
+
+| Repository | clone-alert | PMD CPD | Speed‑up | Peak RAM (clone vs PMD) | Agreement with PMD¹ |
+| --- | --- | --- | --- | --- | --- |
+| `nestjs/nest` | **1.8 s** | 52.7 s | **30×** | 203 MB vs 500 MB (2.5× less) | 100% |
+| `angular/components` | **1.5 s** | 42.5 s | **28×** | 338 MB vs 577 MB (1.7× less) | 95%² |
+| `microsoft/playwright` | **9.3 s** | 153 s | **16×** | 838 MB vs 1.4 GB (1.7× less) | 99.98% |
+| `vercel/next.js` | **5.8 s** | 73.4 s | **13×** | 1.3 GB vs 1.9 GB (1.4× less) | 99.2% |
+| `nrwl/nx` | **8.6 s** | 84.1 s | **10×** | 2.1 GB vs 3.3 GB (1.6× less) | 99.9% |
+
+<sub>¹ Jaccard overlap of the file pairs both tools flag as duplicated. ² `angular/components` ships ~20 near‑identical table demos sharing the same 398‑token block. clone-alert and PMD cut that clone's boundary **identically** (398, 391, 390, 210… tokens, token‑for‑token); they only disagree on *which* of the interchangeable demo files get grouped into the same `<duplication>` — a symmetric clustering tie‑break, not missed or mis‑sized duplication. On this small sample (~2 000 file pairs) that grouping noise is the whole 5%.</sub>
+
+### Same tokens as PMD — verified, not approximated
+
+The clone-alert TypeScript tokenizer is **identical to PMD's**, byte for byte. It is checked in CI against **PMD's own original tokenizer conformance fixtures** (vendored verbatim from the PMD repository): every token's image, line, and column must match PMD's golden output, element for element. clone-alert passes the full suite.
+
+It earns that parity without reimplementing PMD's grammar: clone-alert lexes with the **real TypeScript compiler `Scanner`** — the same lexer `tsc` uses. PMD lexes TypeScript with a hand-maintained JavaCC grammar that trails the language. So clone-alert is **1:1 with PMD where PMD can lex, and still correct on modern syntax PMD's grammar can't** (`satisfies`, `using`, decorators, template‑literal types, newer operators).
+
+### Where the numbers differ from PMD, and why
+
+Because the tokens are identical and the match engine is a faithful port of PMD's `MatchCollector`, the residual differences are **never missed or invented duplication** — they live entirely in how identical matches are *bucketed*:
+
+- **Grouping.** The same set of pairwise matches is occasionally packed into a different number of `<duplication>` groups (e.g. 30 vs 31 occurrences). Same clones, different bucketing; it nudges raw counts by ~2%.
+- **Anchor jitter.** In hyper‑repetitive monorepo code (nx), a block repeated dozens of times can be anchored one line apart by each tool. Line‑exact that looks like a gap; by *which files share duplication* it's **99.9%**, and the divergence is **symmetric** (each tool has equally many "own" matches) — so it's reporting noise, not a detection error in either direction.
+
+## Comparison
+
+| | clone-alert | PMD CPD | jscpd |
+| --- | --- | --- | --- |
+| TS/JS/JSX/TSX | ✅ | ✅ | ✅ |
+| Vue `<template>` markup | ✅ | ➖ | partial |
+| Svelte markup | ✅ (Svelte 5+) | ➖ | ➖ |
+| Angular templates | ✅ | ➖ | flat HTML only |
+| PMD CPD algorithm parity | ✅ | — | ➖ |
+| Install size | tiny (1 dep) | JVM required | npm package |
+
+## Development
+
+```sh
+npm install
+npm run build        # compile to dist/
+npm test             # build + Vitest suite
+npm run lint         # Biome + Knip + type‑check + self‑CPD
+npm run compare:pmd -- /path/to/project --minimum-tokens 50
+```
+
+`npm run compare:pmd` runs PMD CPD, clone-alert, and jscpd on the same file tree and prints a JSON summary of time, peak RSS, duplicate counts, occurrences, and overlap. (jscpd is not a dependency; install it separately or pass `--jscpd <command>`.)
+
+## Keywords
+
+copy‑paste detector · duplicate code finder · code clone detection · CPD · PMD CPD alternative · jscpd alternative · TypeScript duplicate code · JavaScript duplicate code · JSX/TSX clones · Vue / Svelte / Angular duplication · DRY · static analysis · code quality · CI lint.
+
+## License
+
+[MIT](./LICENSE)

package/dist/angular.d.ts

@@ -0,0 +1,23 @@
+import { type RawToken } from './core';
+import { type TokenizeOptions } from './tokenizers';
+/**
+ * Tokenize an Angular HTML template (external `.html` or inline). Two layers:
+ * (1) structure — tags, attribute names, static text; (2) binding/interpolation/
+ * block expressions — an AST walk over @angular/compiler with the same id/literal
+ * normalization as in script. All images are S-prefixed (see NG/NG_ID/NG_LIT) so
+ * there are no cross-matches with script tokens.
+ *
+ * Expression sub-token positions are inherited from the enclosing (host) node:
+ * matching is exact, report granularity is at the binding-line level (no line map
+ * is built).
+ */
+export declare function tokenizeAngularHtml(filePath: string, template: string, base?: {
+    line: number;
+    col: number;
+}, options?: TokenizeOptions): RawToken[];
+/** Extract inline templates from `@Component({ template: \`...\` })`. */
+export declare function extractAngularInlineTemplates(filePath: string, source: string): {
+    code: string;
+    line: number;
+    col: number;
+}[];

package/dist/angular.js

@@ -0,0 +1,296 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeAngularHtml = tokenizeAngularHtml;
+exports.extractAngularInlineTemplates = extractAngularInlineTemplates;
+/**
+ * Tokenizer extension for Angular templates (external `.html` and inline
+ * `@Component`). Built on top of the shared layer in tokenizers.ts
+ * (optional/moduleResolveDirs/remap) and the shared sentinel `S` from core.ts.
+ * The core (core.ts) knows nothing about Angular.
+ *
+ * @packageDocumentation
+ */
+const ts = __importStar(require("typescript"));
+const core_1 = require("./core");
+const tokenizers_1 = require("./tokenizers");
+// Token namespace for Angular template expressions. The S prefix guarantees these
+// images never collide with script tokens (no .ts<->template cross-matches).
+const NG = `${core_1.S}NG:`; // prefix for structural markers / expression names
+const NG_ID = `${core_1.S}NGID`; // normalized template identifier (ignoreIdentifiers)
+const NG_LIT = `${core_1.S}NGLIT`; // normalized template literal (ignoreLiterals)
+const NG_TEXT = `${core_1.S}NGTEXT`; // static template text
+let warnedNg = false;
+/**
+ * Tokenize an Angular HTML template (external `.html` or inline). Two layers:
+ * (1) structure — tags, attribute names, static text; (2) binding/interpolation/
+ * block expressions — an AST walk over @angular/compiler with the same id/literal
+ * normalization as in script. All images are S-prefixed (see NG/NG_ID/NG_LIT) so
+ * there are no cross-matches with script tokens.
+ *
+ * Expression sub-token positions are inherited from the enclosing (host) node:
+ * matching is exact, report granularity is at the binding-line level (no line map
+ * is built).
+ */
+function tokenizeAngularHtml(filePath, template, base = { line: 1, col: 1 }, options) {
+    const o = { ...tokenizers_1.DEFAULTS, ...options };
+    const ngc = (0, tokenizers_1.optional)('@angular/compiler', (0, tokenizers_1.moduleResolveDirs)(filePath));
+    if (!ngc || typeof ngc.parseTemplate !== 'function') {
+        if (!warnedNg) {
+            console.warn('[cpd] Angular template skipped: install @angular/compiler');
+            warnedNg = true;
+        }
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = ngc.parseTemplate(template, filePath, { preserveWhitespaces: false });
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || !Array.isArray(parsed.nodes))
+        return [];
+    const local = [];
+    const emit = (image, node) => {
+        const sp = node?.sourceSpan ?? node?.startSourceSpan;
+        const loc = sp?.start;
+        local.push({ image, line: (loc?.line ?? 0) + 1, column: (loc?.col ?? 0) + 1 });
+    };
+    const emitId = (name, host) => emit(o.ignoreIdentifiers ? NG_ID : `${NG}id:${String(name)}`, host);
+    const emitLit = (value, host) => emit(o.ignoreLiterals ? NG_LIT : `${NG}lit:${JSON.stringify(value)}`, host);
+    // Walk a binding expression. host is the structural node whose coordinates we inherit.
+    const walkExpr = (ast, host) => {
+        if (ast == null || typeof ast !== 'object')
+            return;
+        // ASTWithSource is a wrapper; unwrap it down to the actual expression.
+        if (ast.ast && typeof ast.ast === 'object')
+            return walkExpr(ast.ast, host);
+        switch (ast.constructor?.name) {
+            case 'Interpolation':
+                for (const e of ast.expressions ?? [])
+                    walkExpr(e, host);
+                return;
+            case 'Binary':
+                emit(`${NG}op:${ast.operation}`, host);
+                walkExpr(ast.left, host);
+                walkExpr(ast.right, host);
+                return;
+            case 'Unary':
+                emit(`${NG}op:${ast.operator}`, host);
+                walkExpr(ast.expr, host);
+                return;
+            case 'PrefixNot':
+                emit(`${NG}op:!`, host);
+                walkExpr(ast.expression, host);
+                return;
+            case 'NonNullAssert':
+                emit(`${NG}!.`, host);
+                walkExpr(ast.expression, host);
+                return;
+            case 'Conditional':
+                emit(`${NG}?:`, host);
+                walkExpr(ast.condition, host);
+                walkExpr(ast.trueExp, host);
+                walkExpr(ast.falseExp, host);
+                return;
+            case 'PropertyRead':
+                walkExpr(ast.receiver, host);
+                emitId(ast.name, host);
+                return;
+            case 'SafePropertyRead':
+                walkExpr(ast.receiver, host);
+                emit(`${NG}?.`, host);
+                emitId(ast.name, host);
+                return;
+            case 'KeyedRead':
+                walkExpr(ast.receiver, host);
+                emit(`${NG}[]`, host);
+                walkExpr(ast.key, host);
+                return;
+            case 'SafeKeyedRead':
+                walkExpr(ast.receiver, host);
+                emit(`${NG}?.[]`, host);
+                walkExpr(ast.key, host);
+                return;
+            case 'Call':
+            case 'SafeCall':
+                walkExpr(ast.receiver, host);
+                emit(`${NG}()`, host);
+                for (const a of ast.args ?? [])
+                    walkExpr(a, host);
+                return;
+            case 'BindingPipe':
+                walkExpr(ast.exp, host);
+                emit(`${NG}pipe`, host);
+                emitId(ast.name, host);
+                for (const a of ast.args ?? [])
+                    walkExpr(a, host);
+                return;
+            case 'LiteralArray':
+                emit(`${NG}[arr]`, host);
+                for (const e of ast.expressions ?? [])
+                    walkExpr(e, host);
+                return;
+            case 'LiteralMap':
+                emit(`${NG}{map}`, host);
+                for (const k of ast.keys ?? [])
+                    emitId(k?.key, host);
+                for (const v of ast.values ?? [])
+                    walkExpr(v, host);
+                return;
+            case 'LiteralPrimitive':
+                emitLit(ast.value, host);
+                return;
+            case 'ThisReceiver':
+                emit(`${NG}this`, host);
+                return;
+            case 'ParenthesizedExpression':
+                walkExpr(ast.expression, host);
+                return;
+            case 'ImplicitReceiver':
+            case 'EmptyExpr':
+                return; // root component context — no token needed
+        }
+    };
+    const walk = (node) => {
+        if (node == null)
+            return;
+        const walkAll = (items) => {
+            for (const item of items ?? [])
+                walk(item);
+        };
+        // All of a node's binding collections (common to Element and Template/ng-template).
+        const walkBindings = (n) => {
+            walkAll(n.attributes);
+            walkAll(n.inputs);
+            walkAll(n.outputs);
+            walkAll(n.directives);
+            walkAll(n.references);
+        };
+        // Element (has a tag name + children)
+        if (typeof node.name === 'string' && Array.isArray(node.children)) {
+            emit(`${NG}<${node.name}`, node);
+            walkBindings(node);
+            walkAll(node.children);
+            return;
+        }
+        // Containers: ng-template, control-flow blocks (@if/@for/@switch/@defer).
+        // node.expression also catches leaf blocks without children (@case (…) -> SwitchBlockCase).
+        if (Array.isArray(node.children) ||
+            Array.isArray(node.branches) ||
+            Array.isArray(node.cases) ||
+            Array.isArray(node.groups) ||
+            node.expression) {
+            if (typeof node.tagName === 'string')
+                emit(`${NG}<${node.tagName}`, node);
+            // Block control expressions (@for of …; track …; @if/@case (…)).
+            if (node.expression) {
+                emit(`${NG}@expr`, node);
+                walkExpr(node.expression, node);
+            }
+            if (node.trackBy) {
+                emit(`${NG}@track`, node);
+                walkExpr(node.trackBy, node);
+            }
+            walkBindings(node);
+            walkAll(node.templateAttrs); // *ngIf / *ngFor microsyntax
+            walkAll(node.variables); // let-… on ng-template
+            walkAll(node.item ? [node.item] : undefined);
+            walkAll(node.children);
+            walkAll(node.branches);
+            walkAll(node.cases);
+            walkAll(node.groups);
+            walk(node.empty);
+            return;
+        }
+        // Attribute / input / output / reference / variable: the name is structural,
+        // the value/handler is an expression (if any), static is a literal.
+        if (typeof node.name === 'string') {
+            emit(`${NG}@${node.name}`, node);
+            if (node.value && typeof node.value === 'object')
+                walkExpr(node.value, node);
+            else if (typeof node.value === 'string' && node.value.length)
+                emitLit(node.value, node);
+            if (node.handler && typeof node.handler === 'object')
+                walkExpr(node.handler, node);
+            return;
+        }
+        // BoundText / interpolation (value is an AST expression)
+        if (node.value && typeof node.value === 'object') {
+            walkExpr(node.value, node);
+            return;
+        }
+        // Static text
+        if (typeof node.value === 'string') {
+            if (node.value.trim().length)
+                emit(NG_TEXT, node);
+            return;
+        }
+    };
+    for (const n of parsed.nodes)
+        walk(n);
+    return local.map((t) => (0, tokenizers_1.remap)(t, base.line, base.col));
+}
+/** Extract inline templates from `@Component({ template: \`...\` })`. */
+function extractAngularInlineTemplates(filePath, source) {
+    const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const result = [];
+    const visit = (node) => {
+        if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+            const callee = node.expression.expression;
+            const name = ts.isIdentifier(callee) ? callee.text : '';
+            const arg = node.expression.arguments[0];
+            if (name === 'Component' && arg && ts.isObjectLiteralExpression(arg)) {
+                for (const p of arg.properties) {
+                    if (!ts.isPropertyAssignment(p) || !p.name || !ts.isIdentifier(p.name))
+                        continue;
+                    if (p.name.text !== 'template')
+                        continue;
+                    const init = p.initializer;
+                    if (ts.isStringLiteralLike(init)) {
+                        // position of the first content char (after the quote/backtick)
+                        const contentStart = init.getStart(sf) + 1;
+                        const { line, character } = sf.getLineAndCharacterOfPosition(contentStart);
+                        result.push({ code: init.text, line: line + 1, col: character + 1 });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return result;
+}

package/dist/cli.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { type CpdOptions } from './index';
+type ReportFormat = 'text' | 'xml' | 'json';
+interface CliOptions extends CpdOptions {
+    paths: string[];
+    extensions: Set<string>;
+    excludePatterns: string[];
+    format: ReportFormat;
+    failOnViolation: boolean;
+}
+declare function main(argv: string[]): number;
+declare function parseArgs(argv: string[]): CliOptions;
+declare function collectFiles(paths: string[], extensions: Set<string>, excludePatterns?: string[]): string[];
+export { collectFiles, main, parseArgs };