clone-alert 0.3.0

package/dist/tokenizers.js

@@ -0,0 +1,392 @@
+"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.DEFAULTS = void 0;
+exports.optional = optional;
+exports.moduleResolveDirs = moduleResolveDirs;
+exports.remap = remap;
+exports.tokenizeTypeScript = tokenizeTypeScript;
+exports.scriptKindFor = scriptKindFor;
+/**
+ * The TypeScript/JavaScript tokenizer plus the shared helpers used by every
+ * framework tokenizer extension (`optional`, `moduleResolveDirs`, `remap`).
+ *
+ * @packageDocumentation
+ */
+const ts = __importStar(require("typescript"));
+const core_1 = require("./core");
+exports.DEFAULTS = {
+    ignoreIdentifiers: false,
+    ignoreLiterals: false,
+    pmdTypescriptCompatibility: true,
+    svelteTemplates: true,
+    vueTemplates: true,
+};
+/**
+ * Load an optional compiler (`@angular/compiler`, `@vue/compiler-sfc`, `svelte`)
+ * — a peerDependency. Resolution starts FROM the analyzed file and walks up the
+ * tree (so we use the compiler version installed in the scanned project), and
+ * only then falls back to clone-alert's own node_modules. `fromPaths` is usually
+ * `[dirname(filePath)]`; Node climbs node_modules from there.
+ */
+function optional(name, fromPaths) {
+    try {
+        const id = require.resolve(name, fromPaths && fromPaths.length ? { paths: fromPaths } : undefined);
+        return require(id);
+    }
+    catch {
+        if (fromPaths && fromPaths.length) {
+            try {
+                return require(name);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+}
+/**
+ * Starting point for resolving a peer compiler: the directory of the analyzed
+ * file. Node walks up node_modules from there to the project root.
+ */
+function moduleResolveDirs(filePath) {
+    const slash = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\'));
+    return slash > 0 ? [filePath.slice(0, slash)] : [];
+}
+/**
+ * Remap an embedded block's positions into file coordinates. Block tokens are
+ * counted from (0,0) within the block; baseLine/baseCol (1-based) give the
+ * absolute start of the block. The column shift applies only to the block's
+ * first line.
+ */
+function remap(tok, baseLine, baseCol) {
+    const firstLine = tok.line === 1;
+    const endFirstLine = (tok.endLine ?? tok.line) === 1;
+    return {
+        image: tok.image,
+        line: baseLine + tok.line - 1,
+        column: firstLine ? baseCol + tok.column - 1 : tok.column,
+        endLine: baseLine + (tok.endLine ?? tok.line) - 1,
+        endColumn: endFirstLine ? baseCol + (tok.endColumn ?? tok.column) - 1 : (tok.endColumn ?? tok.column),
+        barrier: tok.barrier,
+    };
+}
+/**
+ * Tokenize TS / TSX / JSX via the TypeScript scanner. CPD counts the stream of
+ * lexical tokens, including keywords and punctuation.
+ */
+function tokenizeTypeScript(filePath, source, opts = {}, scriptKind = ts.ScriptKind.TS) {
+    const o = { ...exports.DEFAULTS, ...opts };
+    // This used to call ts.createSourceFile (a full AST parse) only to map
+    // positions. The AST is not needed — we use the same line map TS builds under
+    // the hood for getLineAndCharacterOfPosition, without parsing. See createLineMap.
+    const sf = createLineMap(source);
+    const suppressedRanges = findCpdSuppressedRanges(source);
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, scriptKind === ts.ScriptKind.TSX || scriptKind === ts.ScriptKind.JSX
+        ? ts.LanguageVariant.JSX
+        : ts.LanguageVariant.Standard, source);
+    const out = [];
+    let previousTokenKind = null;
+    const normalize = (kind, text) => {
+        switch (kind) {
+            case ts.SyntaxKind.Identifier:
+            case ts.SyntaxKind.PrivateIdentifier:
+                return o.ignoreIdentifiers ? core_1.TS_ID : text;
+            case ts.SyntaxKind.StringLiteral:
+            case ts.SyntaxKind.NumericLiteral:
+            case ts.SyntaxKind.BigIntLiteral:
+            case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+            case ts.SyntaxKind.RegularExpressionLiteral:
+            case ts.SyntaxKind.TemplateHead:
+            case ts.SyntaxKind.TemplateMiddle:
+            case ts.SyntaxKind.TemplateTail:
+                return o.ignoreLiterals ? core_1.TS_LIT : normalizeStringContinuation(text);
+            case ts.SyntaxKind.JsxText: {
+                const t = text.trim();
+                if (!t)
+                    return null; // drop empty JSX text
+                return o.ignoreLiterals ? core_1.TS_LIT : t;
+            }
+            default:
+                return text;
+        }
+    };
+    // PMD typescript compatibility is enabled only for TS files. .ts/.tsx (flag
+    // ON): templates are split into PMD-typescript atoms (backtick / ${ / } / one
+    // per text char — grammar TypeScriptLexer.g4 TemplateStringAtom: ~[`\\]) and
+    // regexp is collapsed. .js/.jsx, or flag OFF: the native scanner (a template
+    // is one token, no PMD massaging).
+    const pmdTypeScript = o.pmdTypescriptCompatibility && isTypeScriptFile(filePath, scriptKind);
+    const splitTemplates = pmdTypeScript;
+    // Brace depth inside each active ${…} interpolation. At zero, the next `}`
+    // closes the interpolation -> rescan it as TemplateMiddle/Tail.
+    const templateBraceDepth = [];
+    const bumpTemplateDepth = (kind) => {
+        if (!splitTemplates)
+            return;
+        const top = templateBraceDepth.length - 1;
+        switch (kind) {
+            case ts.SyntaxKind.TemplateHead:
+                templateBraceDepth.push(0);
+                break;
+            case ts.SyntaxKind.TemplateTail:
+                templateBraceDepth.pop();
+                break;
+            case ts.SyntaxKind.OpenBraceToken:
+                if (top >= 0)
+                    templateBraceDepth[top]++;
+                break;
+            case ts.SyntaxKind.CloseBraceToken:
+                if (top >= 0)
+                    templateBraceDepth[top]--;
+                break;
+            default:
+                break;
+        }
+    };
+    for (;;) {
+        let kind = scanner.scan();
+        if (kind === ts.SyntaxKind.EndOfFileToken)
+            break;
+        // Closing `}` of an interpolation: rescan it as a template continuation.
+        if (splitTemplates &&
+            kind === ts.SyntaxKind.CloseBraceToken &&
+            templateBraceDepth.length > 0 &&
+            templateBraceDepth[templateBraceDepth.length - 1] === 0) {
+            kind = scanner.reScanTemplateToken(false);
+        }
+        const tokenStart = scanner.getTokenPos();
+        if (isSuppressed(tokenStart, suppressedRanges)) {
+            bumpTemplateDepth(kind); // keep the stack in sync through CPD-OFF
+            continue;
+        }
+        if (pmdTypeScript && kind === ts.SyntaxKind.SlashToken && canStartPmdRegexpLiteral(previousTokenKind)) {
+            kind = scanner.reScanSlashToken();
+        }
+        // typescript mode: split part of the template into PMD atoms.
+        if (splitTemplates && isTemplatePart(kind)) {
+            bumpTemplateDepth(kind);
+            for (const atom of expandTemplateSpan(source, sf, tokenStart, scanner.getTextPos(), o)) {
+                out.push(atom);
+            }
+            previousTokenKind = kind;
+            continue;
+        }
+        // native mode: the whole template with substitutions is one token.
+        if (!splitTemplates && kind === ts.SyntaxKind.TemplateHead) {
+            const templateEnd = findTemplateLiteralEnd(source, tokenStart);
+            scanner.setTextPos(templateEnd);
+            const { line, character } = sf.getLineAndCharacterOfPosition(tokenStart);
+            const end = positionAtTokenEnd(sf, templateEnd);
+            out.push({
+                image: o.ignoreLiterals ? core_1.TS_LIT : source.slice(tokenStart, templateEnd),
+                line: line + 1,
+                column: character + 1,
+                endLine: end.line,
+                endColumn: end.column,
+            });
+            previousTokenKind = kind;
+            continue;
+        }
+        bumpTemplateDepth(kind); // balance { } inside an interpolation
+        const image = normalize(kind, normalizeStringContinuation(scanner.getTokenText()));
+        if (image === null)
+            continue;
+        const { line, character } = sf.getLineAndCharacterOfPosition(tokenStart);
+        const end = positionAtTokenEnd(sf, scanner.getTextPos());
+        out.push({
+            image,
+            line: line + 1,
+            column: character + 1,
+            endLine: end.line,
+            endColumn: end.column,
+        });
+        previousTokenKind = kind;
+    }
+    return out;
+}
+function canStartPmdRegexpLiteral(previousKind) {
+    if (previousKind === null) {
+        return true;
+    }
+    switch (previousKind) {
+        case ts.SyntaxKind.Identifier:
+        case ts.SyntaxKind.PrivateIdentifier:
+        case ts.SyntaxKind.StringLiteral:
+        case ts.SyntaxKind.NumericLiteral:
+        case ts.SyntaxKind.BigIntLiteral:
+        case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+        case ts.SyntaxKind.RegularExpressionLiteral:
+        case ts.SyntaxKind.ThisKeyword:
+        case ts.SyntaxKind.SuperKeyword:
+        case ts.SyntaxKind.TrueKeyword:
+        case ts.SyntaxKind.FalseKeyword:
+        case ts.SyntaxKind.NullKeyword:
+        case ts.SyntaxKind.CloseParenToken:
+        case ts.SyntaxKind.CloseBracketToken:
+        case ts.SyntaxKind.CloseBraceToken:
+        case ts.SyntaxKind.PlusPlusToken:
+        case ts.SyntaxKind.MinusMinusToken:
+            return false;
+        default:
+            return true;
+    }
+}
+// PMD typescript compatibility applies only to TS files; .js/.jsx go through the
+// native scanner with no PMD massaging.
+function isTypeScriptFile(filePath, scriptKind) {
+    const ext = pathExt(filePath);
+    if (ext === '.ts' || ext === '.tsx' || ext === '.mts' || ext === '.cts')
+        return true;
+    if (ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs')
+        return false;
+    return scriptKind === ts.ScriptKind.TS || scriptKind === ts.ScriptKind.TSX;
+}
+function pathExt(filePath) {
+    const dot = filePath.lastIndexOf('.');
+    return dot === -1 ? '' : filePath.slice(dot).toLowerCase();
+}
+function createLineMap(source) {
+    const api = ts;
+    const compute = api.computeLineStarts;
+    const lineAndChar = api.computeLineAndCharacterOfPosition;
+    if (compute && lineAndChar) {
+        const lineStarts = compute(source);
+        return { getLineAndCharacterOfPosition: (pos) => lineAndChar(lineStarts, pos) };
+    }
+    const sf = ts.createSourceFile('_.ts', source, ts.ScriptTarget.Latest, false);
+    return { getLineAndCharacterOfPosition: (pos) => sf.getLineAndCharacterOfPosition(pos) };
+}
+function positionAtTokenEnd(sf, offset) {
+    const { line, character } = sf.getLineAndCharacterOfPosition(offset);
+    return { line: line + 1, column: character + 1 };
+}
+function normalizeStringContinuation(text) {
+    return text.replace(/\\\r?\n\s*/g, '');
+}
+function findTemplateLiteralEnd(source, start) {
+    let expressionDepth = 0;
+    for (let i = start + 1; i < source.length; i++) {
+        const char = source[i];
+        if (char === '\\') {
+            i++;
+            continue;
+        }
+        if (char === '`' && expressionDepth === 0) {
+            return i + 1;
+        }
+        if (char === '$' && source[i + 1] === '{') {
+            expressionDepth++;
+            i++;
+            continue;
+        }
+        if (char === '}' && expressionDepth > 0) {
+            expressionDepth--;
+        }
+    }
+    return source.length;
+}
+function isTemplatePart(kind) {
+    return (kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral ||
+        kind === ts.SyntaxKind.TemplateHead ||
+        kind === ts.SyntaxKind.TemplateMiddle ||
+        kind === ts.SyntaxKind.TemplateTail);
+}
+// Split a chunk of a template literal into PMD-typescript atoms: backtick, `${`,
+// `}`, and an escape `\X` are one token each; everything else (text, spaces,
+// newlines) is one token per character (grammar: TemplateStringAtom: ~[`\\]).
+function expandTemplateSpan(source, sf, start, end, opts) {
+    const atoms = [];
+    let i = start;
+    while (i < end) {
+        let len = 1;
+        const char = source[i];
+        if (char === '\\' && i + 1 < end) {
+            len = 2; // escape atom
+        }
+        else if (char === '$' && source[i + 1] === '{') {
+            len = 2; // start of an interpolation
+        }
+        const raw = source.slice(i, i + len);
+        const structural = raw === '`' || raw === '${' || raw === '}';
+        const s = sf.getLineAndCharacterOfPosition(i);
+        const e = sf.getLineAndCharacterOfPosition(i + len);
+        atoms.push({
+            image: !structural && opts.ignoreLiterals ? core_1.TS_LIT : raw,
+            line: s.line + 1,
+            column: s.character + 1,
+            endLine: e.line + 1,
+            endColumn: e.character + 1,
+        });
+        i += len;
+    }
+    return atoms;
+}
+function isSuppressed(offset, ranges) {
+    return ranges.some((range) => offset >= range.start && offset < range.end);
+}
+function findCpdSuppressedRanges(source) {
+    const ranges = [];
+    const comments = source.matchAll(/\/\/[^\r\n]*|\/\*[\s\S]*?\*\//g);
+    let start = null;
+    for (const comment of comments) {
+        const image = comment[0];
+        const index = comment.index;
+        if (image.includes('CPD-OFF') && start === null) {
+            start = index;
+        }
+        if (image.includes('CPD-ON') && start !== null) {
+            ranges.push({ start, end: index + image.length });
+            start = null;
+        }
+    }
+    if (start !== null) {
+        ranges.push({ start, end: source.length });
+    }
+    return ranges;
+}
+const TSX_EXT = new Set(['.tsx', '.jsx']);
+const JS_EXT = new Set(['.js', '.mjs', '.cjs']);
+function scriptKindFor(ext) {
+    if (TSX_EXT.has(ext))
+        return ts.ScriptKind.TSX;
+    if (JS_EXT.has(ext))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+// Vue (.vue) and Svelte (.svelte) live in their own extension modules src/vue.ts
+// and src/svelte.ts, modeled on src/angular.ts — each tokenizes both <script> and
+// markup (descriptor.template.ast / ast.fragment).

package/dist/vue.d.ts

@@ -0,0 +1,4 @@
+import { type RawToken } from './core';
+import { type TokenizeOptions } from './tokenizers';
+/** Tokenize a `.vue` single-file component (`<script>` blocks + markup). */
+export declare function tokenizeVue(filePath: string, source: string, options?: TokenizeOptions): RawToken[];

package/dist/vue.js

@@ -0,0 +1,189 @@
+"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.tokenizeVue = tokenizeVue;
+/**
+ * `.vue` tokenizer: `<script>`/`<script setup>` + markup (descriptor.template.ast).
+ * Built on top of the shared layer in tokenizers.ts (optional/moduleResolveDirs/
+ * remap/tokenizeTypeScript) and the sentinel `S` from core.ts. The core knows
+ * nothing about Vue. Modeled on src/svelte.ts and src/angular.ts.
+ *
+ * Two token layers:
+ *   1. markup structure (tags, directives, attribute names/values, static text)
+ *      -> images with the VUE prefix (via the sentinel S), so they do NOT match
+ *      script tokens;
+ *   2. binding/interpolation expressions (`{{ … }}`, `:prop`, `v-if`, `@event`)
+ *      -> the same TypeScript in the same component scope, so we slice the source
+ *      and run it through the shared tokenizeTypeScript WITHOUT a prefix, so a
+ *      duplicated expression across template<->script is caught.
+ *
+ * @packageDocumentation
+ */
+const ts = __importStar(require("typescript"));
+const core_1 = require("./core");
+const tokenizers_1 = require("./tokenizers");
+const VUE = `${core_1.S}VUE:`; // structural markup marker
+const VUE_TEXT = `${core_1.S}VUETEXT`; // non-empty static text
+const VUE_LIT = `${core_1.S}VUELIT`; // normalized static attribute value (ignoreLiterals)
+// Numeric NodeTypes from @vue/compiler-core; stable across all of Vue 3.
+const N_ELEMENT = 1;
+const N_TEXT = 2;
+const N_COMMENT = 3;
+const N_INTERPOLATION = 5;
+const N_ATTRIBUTE = 6;
+const N_DIRECTIVE = 7;
+let warnedVue = false;
+/** Tokenize a `.vue` single-file component (`<script>` blocks + markup). */
+function tokenizeVue(filePath, source, options = {}) {
+    const o = { ...tokenizers_1.DEFAULTS, ...options };
+    const sfc = (0, tokenizers_1.optional)('@vue/compiler-sfc', (0, tokenizers_1.moduleResolveDirs)(filePath));
+    if (!sfc || typeof sfc.parse !== 'function') {
+        if (!warnedVue) {
+            console.warn('[cpd] .vue skipped: install @vue/compiler-sfc');
+            warnedVue = true;
+        }
+        return [];
+    }
+    let descriptor;
+    try {
+        ({ descriptor } = sfc.parse(source, { filename: filePath }));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    // --- <script setup> and <script>: plain TS/JS, like a regular file ---
+    for (const block of [descriptor.scriptSetup, descriptor.script]) {
+        if (!block)
+            continue;
+        const lang = block.lang ?? 'js';
+        const kind = lang === 'tsx' || lang === 'jsx' ? ts.ScriptKind.TSX : lang === 'ts' ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+        const baseLine = block.loc.start.line; // 1-based
+        const baseCol = block.loc.start.column; // 1-based
+        for (const t of (0, tokenizers_1.tokenizeTypeScript)(filePath, block.content, o, kind))
+            out.push((0, tokenizers_1.remap)(t, baseLine, baseCol));
+        out.push({ image: '', line: baseLine, column: baseCol, barrier: true });
+    }
+    // --- Markup ---
+    // Tokenized only when the toggle is on (default yes). Markup and script are
+    // usually run at different --minimum-tokens thresholds.
+    const tmpl = descriptor.template;
+    if ((o.vueTemplates ?? true) && tmpl?.ast) {
+        // Vue node coordinates (loc.start.{line,column}) are already absolute to the
+        // file and 1-based — no offset->line/col map is needed (unlike svelte.ts).
+        const emitStruct = (image, node) => {
+            const loc = node?.loc?.start;
+            out.push({ image, line: loc?.line ?? 1, column: loc?.column ?? 1 });
+        };
+        // SIMPLE_EXPRESSION -> slice the source -> shared TS tokenizer -> remap.
+        // id/literal normalization is done by tokenizeTypeScript itself (it is real TS).
+        const emitExpr = (exp) => {
+            const start = exp?.loc?.start;
+            const end = exp?.loc?.end;
+            if (!start || !end || typeof start.offset !== 'number' || typeof end.offset !== 'number')
+                return;
+            const code = source.slice(start.offset, end.offset);
+            if (!code.trim())
+                return;
+            for (const t of (0, tokenizers_1.tokenizeTypeScript)(filePath, code, o, ts.ScriptKind.TS)) {
+                out.push((0, tokenizers_1.remap)(t, start.line, start.column));
+            }
+        };
+        const emitLit = (value, host) => emitStruct(o.ignoreLiterals ? VUE_LIT : `${VUE}lit:${JSON.stringify(value)}`, host);
+        // Canonical directive image: name + static arg + modifiers.
+        // :class -> VUE:bind:class ; @click.stop -> VUE:on:click.stop ; v-if -> VUE:if
+        const directiveImage = (dir) => {
+            let image = `${VUE}${dir.name}`;
+            if (dir.arg && dir.arg.isStatic !== false && typeof dir.arg.content === 'string') {
+                image += `:${dir.arg.content}`;
+            }
+            for (const m of dir.modifiers ?? []) {
+                const content = typeof m === 'string' ? m : m?.content;
+                if (content)
+                    image += `.${content}`;
+            }
+            return image;
+        };
+        const walkProp = (prop) => {
+            if (!prop)
+                return;
+            if (prop.type === N_ATTRIBUTE) {
+                emitStruct(`${VUE}@${prop.name}`, prop);
+                const value = prop.value;
+                if (value && typeof value.content === 'string' && value.content.length)
+                    emitLit(value.content, value);
+                return;
+            }
+            if (prop.type === N_DIRECTIVE) {
+                emitStruct(directiveImage(prop), prop);
+                // Dynamic arg (:[key]) is an expression; the static arg is already in the image.
+                if (prop.arg && prop.arg.isStatic === false)
+                    emitExpr(prop.arg);
+                if (prop.exp)
+                    emitExpr(prop.exp);
+            }
+        };
+        const walk = (node) => {
+            if (!node)
+                return;
+            switch (node.type) {
+                case N_ELEMENT:
+                    emitStruct(`${VUE}<${node.tag}`, node);
+                    for (const p of node.props ?? [])
+                        walkProp(p);
+                    for (const c of node.children ?? [])
+                        walk(c);
+                    return;
+                case N_TEXT:
+                    if (typeof node.content === 'string' && node.content.trim())
+                        emitStruct(VUE_TEXT, node);
+                    return;
+                case N_COMMENT:
+                    return;
+                case N_INTERPOLATION:
+                    emitExpr(node.content);
+                    return;
+                default:
+                    // ROOT and other containers — descend into children.
+                    if (Array.isArray(node.children))
+                        for (const c of node.children)
+                            walk(c);
+            }
+        };
+        out.push({ image: '', line: tmpl.loc?.start?.line ?? 1, column: tmpl.loc?.start?.column ?? 1, barrier: true });
+        walk(tmpl.ast);
+    }
+    return out;
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "clone-alert",
+  "version": "0.3.0",
+  "description": "PMD CPD-compatible copy-paste detector that finds duplicate code in TypeScript, JavaScript, JSX/TSX, Vue, Svelte and Angular.",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "clone-alert": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*",
+    "scripts/compare-pmd-cpd.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "cpd",
+    "copy-paste",
+    "copy-paste-detector",
+    "duplicate-code",
+    "code-duplication",
+    "code-clones",
+    "clone-detection",
+    "pmd",
+    "pmd-cpd",
+    "dry",
+    "static-analysis",
+    "code-quality",
+    "typescript",
+    "javascript",
+    "jsx",
+    "tsx",
+    "vue",
+    "svelte",
+    "angular",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/BaryshevRS/clone-alert.git"
+  },
+  "bugs": {
+    "url": "https://github.com/BaryshevRS/clone-alert/issues"
+  },
+  "homepage": "https://github.com/BaryshevRS/clone-alert#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "biome check .",
+    "check:fix": "biome check --write .",
+    "check-types": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "compare:pmd": "npm run build && node scripts/compare-pmd-cpd.mjs",
+    "lint": "npm run check:fix && npm run lint:knip && npm run check-types && npm run lint:cpd",
+    "lint:cpd": "npm run build && node dist/cli.js --minimum-tokens 70 --files src --extensions ts --format text --fail-on-violation",
+    "lint:knip": "knip",
+    "pack:dry-run": "npm pack --dry-run",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run check && npm run lint:knip && npm run check-types && npm run lint:cpd && npm test",
+    "publish:dry-run": "npm publish --dry-run",
+    "publish:local": "npm publish --registry http://localhost:4873",
+    "publish:local:dry-run": "npm publish --dry-run --registry http://localhost:4873",
+    "test": "npm run build && vitest run",
+    "release": "npm publish"
+  },
+  "dependencies": {
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "@angular/compiler": ">=17.0.0",
+    "@vue/compiler-sfc": ">=3.0.0",
+    "svelte": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@angular/compiler": {
+      "optional": true
+    },
+    "@vue/compiler-sfc": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22.0.2",
+    "@biomejs/biome": "^2.5.0",
+    "@types/node": "^24.0.0",
+    "@vue/compiler-sfc": "^3.5.38",
+    "knip": "^6.5.0",
+    "svelte": "^5.56.3",
+    "vitest": "^4.1.6"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}