@eevee-ta/cli 1.0.1 → 1.3.0

package/dist/src/lib/i18n-scanner.js

@@ -0,0 +1,1172 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+const DEFAULT_INCLUDES = [
+    '**/src/**/*.{js,jsx,mjs,cjs,ts,tsx,vue}',
+    '**/src/main/java/**/*.java',
+    '**/src/main/resources/templates/**/*.{html,htm,jsp,jspf,tag,ftl,vm}',
+];
+const DEFAULT_EXCLUDES = [
+    '**/node_modules/**',
+    '**/.umi/**',
+    '**/.umi-production/**',
+    '**/.umi-test/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/target/**',
+    '**/generated/**',
+    '**/*.min.*',
+    '**/*.d.ts',
+    '**/*.{test,spec}.{js,jsx,mjs,cjs,ts,tsx,vue}',
+    '**/{mock,mocks,__mocks__,fixture,fixtures,__fixtures__}/**',
+    '**/*.{mock,fixture}.{js,jsx,mjs,cjs,ts,tsx,vue}',
+    '**/{mock,fixture}.{js,jsx,mjs,cjs,ts,tsx,vue}',
+    '**/{mock,fixture}*.{js,jsx,mjs,cjs,ts,tsx,vue}',
+];
+const JS_EXTENSIONS = new Set(['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.vue']);
+const MARKUP_EXTENSIONS = new Set(['.html', '.htm', '.jsp', '.jspf', '.tag', '.ftl', '.vm']);
+const HAS_CJK = /[\u3400-\u9fff\uf900-\ufaff]/;
+const CJK_TEXT = /[\u3400-\u9fff\uf900-\ufaff][\u3400-\u9fff\uf900-\ufaff\u3000-\u303f\uff01-\uff5e\s]*/g;
+export async function scanProjectI18n(projectRootInput, options = {}) {
+    const projectRoot = path.resolve(projectRootInput);
+    const rootStat = await stat(projectRoot);
+    if (!rootStat.isDirectory())
+        throw new Error(`项目目录不存在或不是目录: ${projectRoot}`);
+    const config = await loadConfig(projectRoot, options.configPath);
+    const includes = options.includes?.length ? options.includes : config.includes;
+    const excludes = [
+        ...(options.excludes?.length ? options.excludes : config.excludes),
+        ...config.outPaths.map((directory) => `${normalizeGlob(directory)}**`),
+    ];
+    const normalizedOptions = {
+        ...config,
+        includes: includes?.length ? includes : DEFAULT_INCLUDES,
+        excludes: [...new Set([...excludes, ...DEFAULT_EXCLUDES])],
+        excludeAscii: config.excludeAscii ?? true,
+        excludeTrack: config.excludeTrack ?? config.execludeTrack ?? true,
+        checkCallArguments: options.checkCallArguments ?? config.checkCallArguments ?? false,
+        checkAnnotations: options.checkAnnotations ?? config.checkAnnotations ?? false,
+    };
+    const dictionary = await loadDictionary(projectRoot, config.outPaths);
+    const files = await collectFiles(projectRoot, normalizedOptions.includes, normalizedOptions.excludes);
+    const issues = [];
+    for (const file of files) {
+        const content = await readFile(file, 'utf8');
+        const directives = scanJavaScriptDirectives(content);
+        if (directives.fileDisabled)
+            continue;
+        const fileIssues = scanFile({
+            projectRoot,
+            file,
+            content,
+            config: normalizedOptions,
+            dictionary,
+        }).filter((issue) => !directives.disabledLines.has(issue.line));
+        issues.push(...fileIssues);
+    }
+    issues.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column || a.term.localeCompare(b.term));
+    return {
+        projectRoot,
+        configPath: config.configPath,
+        scannedFiles: files.length,
+        dictionaryTerms: dictionary.terms.size,
+        dictionaryTags: [...dictionary.tags.keys()].sort(),
+        issues,
+        ok: issues.length === 0,
+    };
+}
+async function loadConfig(projectRoot, overridePath) {
+    const candidates = overridePath
+        ? [overridePath]
+        : ['intl.json', '.eevee/i18n.json', 'eevee.i18n.json'].map((item) => path.join(projectRoot, item));
+    let selected = null;
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        if ((await stat(resolved).catch(() => undefined))?.isFile()) {
+            selected = resolved;
+            break;
+        }
+    }
+    if (!selected && overridePath)
+        throw new Error(`国际化检查配置不存在: ${overridePath}`);
+    let raw = {};
+    if (selected) {
+        try {
+            raw = JSON.parse(await readFile(selected, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`无法解析国际化配置 ${selected}: ${error.message}`);
+        }
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error(`国际化配置必须是 JSON 对象: ${selected}`);
+    }
+    const outPaths = (raw.outPaths ?? [])
+        .map((item) => typeof item === 'string' ? item : item?.path ?? '')
+        .filter(Boolean)
+        .map((item) => normalizeGlob(item));
+    const legacyProperties = raw.excludePropertys ?? [];
+    const properties = raw.excludeProperties ?? legacyProperties;
+    return {
+        outPaths,
+        includes: raw.includes ?? [],
+        excludes: raw.excludes ?? [],
+        excludeAscii: raw.excludeAscii ?? true,
+        tagMatchMap: raw.tagMatchMap ?? {},
+        excludeProperties: properties,
+        excludeTrack: raw.excludeTrack ?? raw.execludeTrack ?? true,
+        checkCallArguments: raw.checkCallArguments ?? false,
+        checkAnnotations: raw.checkAnnotations ?? false,
+        configPath: selected,
+    };
+}
+async function loadDictionary(projectRoot, outPaths) {
+    const dictionary = { terms: new Map(), tags: new Map() };
+    for (const outputPath of outPaths) {
+        const directory = resolveLegacyProjectPath(projectRoot, outputPath);
+        const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+            if (error.code === 'ENOENT')
+                return [];
+            throw new Error(`无法读取词条输出目录 ${directory}: ${error.message}`);
+        });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (!isDictionaryFile(entry.name))
+                continue;
+            const tag = dictionaryTag(entry.name);
+            const values = await loadDictionaryValues(path.join(directory, entry.name), entry.name);
+            for (const term of values) {
+                if (!term)
+                    continue;
+                const tags = dictionary.terms.get(term) ?? new Set();
+                tags.add(tag);
+                dictionary.terms.set(term, tags);
+                const terms = dictionary.tags.get(tag) ?? new Set();
+                terms.add(term);
+                dictionary.tags.set(tag, terms);
+            }
+        }
+    }
+    return dictionary;
+}
+function resolveLegacyProjectPath(projectRoot, value) {
+    const normalized = toPosix(value);
+    // 旧 intl.json 的 path 虽以 / 开头，但语义是项目根内的路径，而不是文件系统绝对路径。
+    return path.resolve(projectRoot, normalized.startsWith('/') ? normalized.slice(1) : normalized);
+}
+function isDictionaryFile(name) {
+    const extension = path.extname(name);
+    if (!['.json', '.js', '.cjs', '.mjs', '.properties'].includes(extension))
+        return false;
+    const lower = name.toLowerCase();
+    return lower.startsWith('zh-cn') || (/^messages/.test(lower) && /(?:zh|cn)/.test(lower));
+}
+function dictionaryTag(name) {
+    if (name.startsWith('zh-CN-')) {
+        const suffix = name.slice('zh-CN-'.length);
+        return suffix.slice(0, suffix.indexOf('.') >= 0 ? suffix.indexOf('.') : undefined) || 'default';
+    }
+    return 'spring';
+}
+async function loadDictionaryValues(file, name) {
+    if (name.endsWith('.properties'))
+        return parseProperties(await readFile(file, 'utf8'));
+    if (name.endsWith('.js') || name.endsWith('.cjs') || name.endsWith('.mjs')) {
+        return parseJavaScriptDictionaryKeys(await readFile(file, 'utf8'));
+    }
+    return flattenKeys(JSON.parse(await readFile(file, 'utf8')));
+}
+function flattenKeys(value, prefix = '') {
+    const keys = [];
+    for (const [key, item] of Object.entries(value)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        keys.push(fullKey);
+        if (item && typeof item === 'object' && !Array.isArray(item)) {
+            keys.push(...flattenKeys(item, fullKey));
+        }
+    }
+    return keys;
+}
+function parseProperties(content) {
+    return content.split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#') && !line.startsWith('!'))
+        .map((line) => {
+        const separator = line.search(/[:=]/);
+        return separator >= 0 ? line.slice(0, separator).trim() : '';
+    })
+        .filter(Boolean);
+}
+function parseJavaScriptDictionaryKeys(content) {
+    const assignment = /(?:export\s+default|module\.exports(?:\.default)?)(?:\s*=\s*)?/.exec(content);
+    const start = content.indexOf('{', assignment ? (assignment.index ?? 0) + assignment[0].length : 0);
+    if (start < 0)
+        return [];
+    const end = matchingBrace(content, start);
+    if (end < 0)
+        return [];
+    const keys = [];
+    let depth = 1;
+    let expectKey = true;
+    let index = start + 1;
+    while (index < end) {
+        index = skipJavaScriptNoise(content, index, !expectKey);
+        if (content[index] === '}')
+            break;
+        if (expectKey) {
+            const key = readJavaScriptKey(content, index);
+            if (!key)
+                return keys;
+            keys.push(key.value);
+            index = skipJavaScriptNoise(content, key.end, false);
+            if (content[index] !== ':')
+                return keys;
+            expectKey = false;
+            index++;
+            continue;
+        }
+        if (content[index] === '{' || content[index] === '[')
+            depth++;
+        else if (content[index] === '}' || content[index] === ']')
+            depth--;
+        else if (content[index] === ',' && depth === 1)
+            expectKey = true;
+        index++;
+    }
+    return keys;
+}
+function matchingBrace(content, start) {
+    let depth = 0;
+    for (let index = start; index < content.length; index++) {
+        index = skipJavaScriptNoise(content, index);
+        if (content[index] === '{')
+            depth++;
+        else if (content[index] === '}') {
+            depth--;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function skipJavaScriptNoise(content, start, skipStrings = true) {
+    let index = start;
+    while (index < content.length) {
+        const char = content[index];
+        if (/\s/.test(char)) {
+            index++;
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '/') {
+            while (index < content.length && content[index] !== '\n')
+                index++;
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            const end = content.indexOf('*/', index + 2);
+            index = end >= 0 ? end + 2 : content.length;
+            continue;
+        }
+        if (skipStrings && (char === '"' || char === "'" || char === '`')) {
+            index++;
+            while (index < content.length && content[index] !== char) {
+                if (content[index] === '\\')
+                    index++;
+                index++;
+            }
+            index++;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function readJavaScriptKey(content, start) {
+    if (content[start] === '"' || content[start] === "'") {
+        const quote = content[start];
+        let index = start + 1;
+        let value = '';
+        while (index < content.length && content[index] !== quote) {
+            if (content[index] === '\\') {
+                value += content[index + 1] ?? '';
+                index += 2;
+                continue;
+            }
+            value += content[index++];
+        }
+        return { value, end: index + 1 };
+    }
+    const match = /^[\w$]+/.exec(content.slice(start));
+    return match ? { value: match[0], end: start + match[0].length } : null;
+}
+async function collectFiles(root, includes, excludes) {
+    const files = [];
+    const ignoredDirectories = new Set(['.git', 'node_modules', 'dist', 'build', 'target', 'generated']);
+    const walk = async (directory) => {
+        const entries = await readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (ignoredDirectories.has(entry.name))
+                    continue;
+                await walk(full);
+            }
+            else if (entry.isFile() && isSourceFile(entry.name)) {
+                const relative = toPosix(path.relative(root, full));
+                if (matchesAny(relative, includes, root) && !matchesAny(relative, excludes, root))
+                    files.push(full);
+            }
+        }
+    };
+    await walk(root);
+    return files.sort((a, b) => a.localeCompare(b));
+}
+function isSourceFile(name) {
+    const extension = path.extname(name).toLowerCase();
+    return JS_EXTENSIONS.has(extension) || extension === '.java' || MARKUP_EXTENSIONS.has(extension);
+}
+function scanFile(context) {
+    const extension = path.extname(context.file).toLowerCase();
+    if (extension === '.java')
+        return scanJava(context);
+    if (MARKUP_EXTENSIONS.has(extension))
+        return scanMarkup(context);
+    return scanJavaScript(context);
+}
+function scanJavaScript(context) {
+    const issues = [];
+    const { tokens, masked } = scanJavaScriptStrings(context.content);
+    for (const token of tokens) {
+        if (!shouldCheckTerm(token.value, context.config))
+            continue;
+        if (isIgnoredJavaScriptToken(token, masked, context.config))
+            continue;
+        const callName = enclosingCallName(masked, token.start);
+        if (isMessageCall(callName)) {
+            issues.push(...checkRegisteredTerm(token, context));
+            continue;
+        }
+        if (context.config.excludeTrack && isTrackCall(callName))
+            continue;
+        if (callName &&
+            !token.template &&
+            !context.config.checkCallArguments &&
+            isDirectCallArgument(masked, token.start, token.end))
+            continue;
+        issues.push(createIssue(context, token, 'javascript', 'no-i18n', `词条【${token.value}】没有国际化`));
+    }
+    if (extensionAllowsMarkup(extensionOf(context.file))) {
+        issues.push(...scanMarkupText(masked, context, true));
+    }
+    return deduplicate(issues);
+}
+function scanMarkup(context) {
+    const issues = [];
+    issues.push(...scanMarkupAttributes(context));
+    issues.push(...scanMarkupText(maskMarkupComments(context.content), context));
+    return deduplicate(issues);
+}
+function scanMarkupText(masked, context, jsxMode = false) {
+    const issues = [];
+    const content = jsxMode
+        ? extractJsxTextSegments(masked)
+        : [
+            [
+                masked
+                    .replace(/<[^>]*>/g, (item) => '\0'.repeat(item.length))
+                    .replace(/\{\{[\s\S]*?\}\}/g, (item) => '\0'.repeat(item.length))
+                    .replace(/(?:\$\{|#\{)[^}]*\}/g, (item) => '\0'.repeat(item.length)),
+                0,
+            ],
+        ];
+    for (const [text, offset] of content) {
+        // TSX 里形如 INTL.操作 / ALERT_INTL.空间 的是成员表达式，不是 JSX 文本。
+        const code = text.replace(/[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$\p{ID_Continue}]+)+/gu, (item) => ' '.repeat(item.length));
+        for (const match of code.matchAll(CJK_TEXT)) {
+            const term = normalizeSpace(decodeHtmlEntities(match[0]));
+            if (!term || !HAS_CJK.test(term))
+                continue;
+            const position = positionAt(context.content, offset + (match.index ?? 0));
+            issues.push(createRawIssue(context, position, term, 'markup', 'no-i18n', `词条【${term}】没有国际化`));
+        }
+    }
+    return issues;
+}
+function extractJsxTextSegments(content, baseOffset = 0) {
+    const segments = [];
+    let segmentStart = -1;
+    let index = 0;
+    const flush = (end) => {
+        if (segmentStart >= 0 && end > segmentStart) {
+            segments.push([content.slice(segmentStart, end), baseOffset + segmentStart]);
+        }
+        segmentStart = -1;
+    };
+    while (index < content.length) {
+        const char = content[index];
+        if (char === '<' && isTagStart(content, index)) {
+            flush(index);
+            const closing = content[index + 1] === '/';
+            const tagEnd = findTagEnd(content, index);
+            if (tagEnd < 0)
+                break;
+            // 标签属性中的 {表达式} 也要递归提取：Tabs/Menu 等常用
+            // `items={[{ children: (<div>中文</div>) }]}` 把 JSX 放进属性，
+            // 若只做括号平衡跳过，其中的裸中文文案会整体漏检。
+            if (!closing) {
+                let cursor = index + 1;
+                while (cursor < tagEnd) {
+                    if (content[cursor] === '{') {
+                        const attrEnd = findBalancedEnd(content, cursor, '{', '}');
+                        if (attrEnd < 0 || attrEnd > tagEnd)
+                            break;
+                        const inner = content.slice(cursor + 1, attrEnd);
+                        if (/<[A-Za-z>]/.test(inner)) {
+                            segments.push(...extractJsxTextSegments(inner, baseOffset + cursor + 1));
+                        }
+                        cursor = attrEnd + 1;
+                        continue;
+                    }
+                    cursor++;
+                }
+            }
+            const selfClosing = content.slice(index + 1, tagEnd).trimEnd().endsWith('/');
+            // 只有 JSX 开始标签后的内容是文本节点；结束标签和自闭合标签后回到 JS 代码。
+            segmentStart = !closing && !selfClosing ? tagEnd + 1 : -1;
+            index = tagEnd + 1;
+            continue;
+        }
+        if (segmentStart >= 0 && char === '{') {
+            flush(index);
+            const expressionEnd = findBalancedEnd(content, index, '{', '}');
+            if (expressionEnd < 0)
+                break;
+            // 表达式内嵌套的 JSX 文本也要提取：`{cond && <div>中文</div>}`、
+            // `{cond ? <A>甲</A> : <B>乙</B>}` 是最常见条件渲染写法，
+            // 若整段跳过花括号会导致其中的裸中文文案全部漏检。
+            const inner = content.slice(index + 1, expressionEnd);
+            if (/<[A-Za-z>]/.test(inner)) {
+                segments.push(...extractJsxTextSegments(inner, baseOffset + index + 1));
+            }
+            index = expressionEnd + 1;
+            segmentStart = index;
+            continue;
+        }
+        index++;
+    }
+    flush(content.length);
+    return segments;
+}
+function isTagStart(content, offset) {
+    const next = content[offset + 1];
+    if (!next || !(/[A-Za-z]/.test(next) || next === '>' || next === '/'))
+        return false;
+    // TSX 中 `FC<Props>` / `Array<string>` / `useRef<HTMLInputElement>(...)` 的 `<` 紧跟在
+    // 普通标识符之后；而 JSX 开始标签前的上一个单词只会是关键字（return 等）或运算符。
+    // 若不区分泛型，`FC<Props>` 的 `Props>` 会被当作未闭合标签吞掉其后内容，
+    // 导致该行之后的所有 JSX 文本（裸中文文案）全部漏检。
+    let previous = offset - 1;
+    while (previous >= 0 && /\s/.test(content[previous]))
+        previous--;
+    if (previous < 0)
+        return true;
+    const before = content[previous];
+    // `=> <div>` / `</div><span>`：`<` 紧跟 `>`/`=`/`(` 等，仍视为 JSX 标签
+    if (before === '>' || before === '=' || before === '(' || before === ',' || before === '&')
+        return true;
+    if (/[A-Za-z0-9_$]/.test(before)) {
+        // 回溯完整单词：是关键字（return/typeof…）则视为 JSX；否则按 TS 泛型跳过
+        let start = previous;
+        while (start >= 0 && /[A-Za-z0-9_$]/.test(content[start]))
+            start--;
+        const word = content.slice(start + 1, previous + 1);
+        return /^(return|typeof|instanceof|in|of|as|satisfies|case|do|else|yield|await|new|delete|void|throw)$/.test(word);
+    }
+    return true;
+}
+function findTagEnd(content, start) {
+    for (let index = start + 1; index < content.length; index++) {
+        if (content[index] === '{') {
+            const end = findBalancedEnd(content, index, '{', '}');
+            if (end < 0)
+                return -1;
+            index = end;
+        }
+        else if (content[index] === '>')
+            return index;
+    }
+    return -1;
+}
+function findBalancedEnd(content, start, open, close) {
+    let depth = 0;
+    for (let index = start; index < content.length; index++) {
+        if (content[index] === open)
+            depth++;
+        else if (content[index] === close) {
+            depth--;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function maskMarkupComments(content) {
+    return content
+        .replace(/<!--[\s\S]*?-->/g, (item) => '\0'.repeat(item.length))
+        .replace(/<%--[\s\S]*?--%>/g, (item) => '\0'.repeat(item.length))
+        .replace(/<%#[\s\S]*?%>/g, (item) => '\0'.repeat(item.length));
+}
+function scanMarkupAttributes(context) {
+    const issues = [];
+    for (const tag of context.content.matchAll(/<[^>]+>/g)) {
+        const tagText = tag[0];
+        const tagOffset = tag.index ?? 0;
+        for (const attribute of tagText.matchAll(/([:@\w.-]+)\s*=\s*(["'])([\s\S]*?)\2/g)) {
+            const name = attribute[1].toLowerCase();
+            const value = attribute[3];
+            if (!HAS_CJK.test(value))
+                continue;
+            const offset = tagOffset + (attribute.index ?? 0);
+            const position = positionAt(context.content, offset);
+            const term = normalizeSpace(decodeHtmlEntities(value));
+            issues.push(createRawIssue(context, position, term, 'markup', 'no-i18n', `词条【${term}】没有国际化`));
+        }
+    }
+    return issues;
+}
+function scanJavaScriptStrings(content) {
+    const output = content.split('');
+    const tokens = scanJavaScriptRange(content, 0, content.length, output);
+    return { tokens, masked: output.join('') };
+}
+function scanJavaScriptDirectives(content) {
+    const directives = {
+        fileDisabled: false,
+        disabledLines: new Set(),
+    };
+    let index = 0;
+    while (index < content.length) {
+        const char = content[index];
+        if (char === '"' || char === "'" || char === '`') {
+            index = skipJavaScriptLiteral(content, index);
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '/') {
+            const end = content.indexOf('\n', index);
+            const stop = end >= 0 ? end : content.length;
+            applyCommentDirective(content, content.slice(index, stop), index, directives);
+            index = stop;
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            const end = content.indexOf('*/', index + 2);
+            const stop = end >= 0 ? end + 2 : content.length;
+            applyCommentDirective(content, content.slice(index, stop), index, directives);
+            index = stop;
+            continue;
+        }
+        index++;
+    }
+    return directives;
+}
+function applyCommentDirective(content, comment, start, directives) {
+    const normalized = comment
+        .replace(/^\/[/*]/, '')
+        .replace(/\*\//g, '')
+        .replace(/\*/g, ' ')
+        .trim();
+    const match = /(?:^|\s)eevee-i18n-disable(-next-line|-file)?(?![\w-])/.exec(normalized);
+    if (!match)
+        return;
+    const line = positionAt(content, start).line;
+    if (match[1] === '-file')
+        directives.fileDisabled = true;
+    else if (match[1] === '-next-line')
+        directives.disabledLines.add(line + 1);
+    else
+        directives.disabledLines.add(line);
+}
+function skipJavaScriptLiteral(content, start) {
+    const quote = content[start];
+    let index = start + 1;
+    while (index < content.length) {
+        const char = content[index];
+        if (char === '\\') {
+            index += 2;
+            continue;
+        }
+        if (quote !== '`' && char === '\n')
+            return index;
+        if (char === quote)
+            return index + 1;
+        if (quote === '`' && char === '$' && content[index + 1] === '{') {
+            const expressionEnd = findTemplateExpressionEnd(content, index + 2, content.length);
+            if (expressionEnd < 0)
+                return content.length;
+            index = expressionEnd + 1;
+            continue;
+        }
+        index++;
+    }
+    return index;
+}
+function scanJavaScriptRange(content, rangeStart, rangeEnd, output) {
+    const tokens = [];
+    let index = rangeStart;
+    while (index < rangeEnd) {
+        const char = content[index];
+        if (char === '/' && content[index + 1] === '/') {
+            while (index < rangeEnd && content[index] !== '\n')
+                output[index++] = ' ';
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            const end = content.indexOf('*/', index + 2);
+            const stop = Math.min(end >= 0 ? end + 2 : content.length, rangeEnd);
+            while (index < stop)
+                output[index++] = ' ';
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            const start = index++;
+            let value = '';
+            while (index < rangeEnd) {
+                const current = content[index];
+                if (current === '\\') {
+                    value += decodeStringEscape(content, index);
+                    output[index++] = ' ';
+                    if (index < rangeEnd)
+                        output[index++] = ' ';
+                    continue;
+                }
+                if (current === char || current === '\n')
+                    break;
+                value += current;
+                output[index++] = ' ';
+            }
+            if (index < rangeEnd && content[index] === char)
+                output[index++] = ' ';
+            const position = positionAt(content, start);
+            tokens.push({ value, start, end: index, line: position.line, column: position.column, template: false });
+            continue;
+        }
+        if (char === '`') {
+            index++;
+            let quasiStart = index;
+            let value = '';
+            const flushQuasi = (end) => {
+                if (!value)
+                    return;
+                const position = positionAt(content, quasiStart);
+                tokens.push({ value, start: quasiStart, end, line: position.line, column: position.column, template: true });
+                value = '';
+            };
+            while (index < rangeEnd) {
+                const current = content[index];
+                if (current === '\\') {
+                    value += decodeStringEscape(content, index);
+                    output[index++] = ' ';
+                    if (index < rangeEnd)
+                        output[index++] = ' ';
+                    continue;
+                }
+                if (current === '`') {
+                    flushQuasi(index);
+                    output[index++] = ' ';
+                    quasiStart = index;
+                    break;
+                }
+                if (current === '$' && content[index + 1] === '{') {
+                    flushQuasi(index);
+                    // 保留 ${ 与 }，让 JSX 扫描仍能识别完整表达式；只清空模板文本。
+                    output[index++] = '$';
+                    output[index++] = '{';
+                    const expressionEnd = findTemplateExpressionEnd(content, index, rangeEnd);
+                    if (expressionEnd < 0)
+                        break;
+                    tokens.push(...scanJavaScriptRange(content, index, expressionEnd, output));
+                    index = expressionEnd;
+                    output[index++] = '}';
+                    quasiStart = index;
+                    continue;
+                }
+                value += current;
+                output[index++] = ' ';
+            }
+            continue;
+        }
+        index++;
+    }
+    return tokens;
+}
+function decodeStringEscape(content, offset) {
+    const escaped = content[offset + 1];
+    if (escaped === 'n')
+        return '\n';
+    if (escaped === 't')
+        return '\t';
+    if (escaped === '\n')
+        return '';
+    return escaped ?? '';
+}
+function findTemplateExpressionEnd(content, start, end) {
+    let depth = 0;
+    let quote;
+    for (let index = start; index < end; index++) {
+        const char = content[index];
+        if (quote) {
+            if (char === '\\')
+                index++;
+            else if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+            continue;
+        }
+        if (char === '{')
+            depth++;
+        else if (char === '}') {
+            if (depth === 0)
+                return index;
+            depth--;
+        }
+    }
+    return -1;
+}
+function scanJava(context) {
+    const issues = [];
+    const annotationRanges = findJavaAnnotationRanges(context.content);
+    const directives = scanJavaDirectives(context.content);
+    if (directives.fileDisabled)
+        return [];
+    const length = context.content.length;
+    let index = 0;
+    while (index < length) {
+        const char = context.content[index];
+        if (char === '/' && context.content[index + 1] === '/') {
+            while (index < length && context.content[index] !== '\n')
+                index++;
+            continue;
+        }
+        if (char === '/' && context.content[index + 1] === '*') {
+            const end = context.content.indexOf('*/', index + 2);
+            index = end >= 0 ? end + 2 : length;
+            continue;
+        }
+        if (char === '"') {
+            const isTextBlock = context.content.slice(index, index + 3) === '"""';
+            const start = index;
+            index += isTextBlock ? 3 : 1;
+            let value = '';
+            while (index < length) {
+                if (isTextBlock && context.content.slice(index, index + 3) === '"""') {
+                    index += 3;
+                    break;
+                }
+                if (!isTextBlock && context.content[index] === '"') {
+                    index++;
+                    break;
+                }
+                if (context.content[index] === '\\') {
+                    const escaped = context.content[index + 1];
+                    value += escaped === 'n' ? '\n' : escaped === 't' ? '\t' : escaped;
+                    index += 2;
+                    continue;
+                }
+                if (!isTextBlock && context.content[index] === '\n')
+                    break;
+                value += context.content[index++];
+            }
+            const term = normalizeSpace(value);
+            if (shouldCheckTerm(term, context.config) &&
+                !directives.disabledLines.has(positionAt(context.content, start).line) &&
+                (context.config.checkAnnotations || !isInRanges(start, annotationRanges))) {
+                const position = positionAt(context.content, start);
+                issues.push(createRawIssue(context, position, term, 'java', 'no-i18n', `词条【${term}】没有国际化`));
+            }
+            continue;
+        }
+        index++;
+    }
+    return deduplicate(issues);
+}
+function scanJavaDirectives(content) {
+    const directives = {
+        fileDisabled: false,
+        disabledLines: new Set(),
+    };
+    let index = 0;
+    while (index < content.length) {
+        const char = content[index];
+        if (char === '/' && content[index + 1] === '/') {
+            const end = content.indexOf('\n', index);
+            const stop = end >= 0 ? end : content.length;
+            applyCommentDirective(content, content.slice(index, stop), index, directives);
+            index = stop;
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            const end = content.indexOf('*/', index + 2);
+            const stop = end >= 0 ? end + 2 : content.length;
+            applyCommentDirective(content, content.slice(index, stop), index, directives);
+            index = stop;
+            continue;
+        }
+        if (char === '"') {
+            const isTextBlock = content.slice(index, index + 3) === '"""';
+            const terminator = isTextBlock ? '"""' : '"';
+            index += isTextBlock ? 3 : 1;
+            while (index < content.length) {
+                if (content[index] === '\\') {
+                    index += 2;
+                    continue;
+                }
+                if (content.slice(index, index + terminator.length) === terminator) {
+                    index += terminator.length;
+                    break;
+                }
+                if (!isTextBlock && content[index] === '\n')
+                    break;
+                index++;
+            }
+            continue;
+        }
+        if (char === '\'') {
+            index++;
+            if (content[index] === '\\')
+                index++;
+            if (index < content.length)
+                index++;
+            continue;
+        }
+        index++;
+    }
+    return directives;
+}
+function findJavaAnnotationRanges(content) {
+    const ranges = [];
+    for (const annotation of content.matchAll(/@[A-Za-z_$][\w$.]*/g)) {
+        let index = (annotation.index ?? 0) + annotation[0].length;
+        while (index < content.length && /\s/.test(content[index]))
+            index++;
+        if (content[index] !== '(')
+            continue;
+        const start = annotation.index ?? 0;
+        let depth = 0;
+        for (; index < content.length; index++) {
+            const char = content[index];
+            if (char === '"') {
+                index++;
+                while (index < content.length && content[index] !== '"') {
+                    if (content[index] === '\\')
+                        index++;
+                    index++;
+                }
+                continue;
+            }
+            if (char === '(')
+                depth++;
+            else if (char === ')') {
+                depth--;
+                if (depth === 0) {
+                    ranges.push([start, index + 1]);
+                    break;
+                }
+            }
+        }
+    }
+    return ranges;
+}
+function isInRanges(offset, ranges) {
+    return ranges.some(([start, end]) => offset >= start && offset < end);
+}
+function shouldCheckTerm(value, config) {
+    const term = value.trim();
+    if (!term)
+        return false;
+    return !config.excludeAscii || HAS_CJK.test(term);
+}
+function isIgnoredJavaScriptToken(token, content, config) {
+    // 普通字符串 token 的 start/end 包含引号；模板 quasi token 不包含反引号。
+    const contentStart = token.start;
+    const before = previousNonWhitespace(content, contentStart);
+    const after = nextNonWhitespace(content, token.end);
+    if (after === ':' && (before === '{' || before === ','))
+        return true;
+    if (before === '.' || after === '.' || (before === '[' && after === ']'))
+        return true;
+    if (isImportOrExportSource(content, token.start))
+        return true;
+    const propertyName = propertyNameForValue(content, contentStart);
+    if (propertyName && config.excludeProperties.includes(propertyName))
+        return true;
+    return false;
+}
+function isImportOrExportSource(content, tokenStart) {
+    const statementStart = Math.max(0, ...[';', '\n', '{', '}'].map((item) => content.lastIndexOf(item, Math.max(0, tokenStart - 1))));
+    const prefix = content.slice(statementStart, tokenStart);
+    return /(?:^|\n)\s*(?:import|export)\b[^;\n]*\bfrom\s*$/.test(prefix);
+}
+function propertyNameForValue(content, tokenStart) {
+    let index = tokenStart - 1;
+    while (index >= 0 && /\s/.test(content[index]))
+        index--;
+    if (index < 0 || content[index] !== ':')
+        return null;
+    index--;
+    while (index >= 0 && /\s/.test(content[index]))
+        index--;
+    const end = index;
+    while (index >= 0 && /[\w$]/.test(content[index]))
+        index--;
+    const name = content.slice(index + 1, end + 1);
+    return /^[\w$]+$/.test(name) ? name : null;
+}
+function previousNonWhitespace(content, index) {
+    for (let i = index - 1; i >= 0; i--)
+        if (!/\s/.test(content[i]))
+            return content[i];
+    return '';
+}
+function nextNonWhitespace(content, index) {
+    for (let i = index; i < content.length; i++)
+        if (!/\s/.test(content[i]))
+            return content[i];
+    return '';
+}
+function enclosingCallName(content, tokenStart) {
+    let depth = 0;
+    for (let index = tokenStart - 1; index >= 0; index--) {
+        const char = content[index];
+        if (char === ')')
+            depth++;
+        else if (char === '(') {
+            if (depth > 0) {
+                depth--;
+                continue;
+            }
+            return identifierBefore(content, index);
+        }
+        else if (char === ';' && depth === 0) {
+            return null;
+        }
+    }
+    return null;
+}
+function identifierBefore(content, parenthesisIndex) {
+    let index = parenthesisIndex - 1;
+    while (index >= 0 && /\s/.test(content[index]))
+        index--;
+    const end = index;
+    while (index >= 0 && /[\w$.]/.test(content[index]))
+        index--;
+    const identifier = content.slice(index + 1, end + 1);
+    return identifier || null;
+}
+function isMessageCall(value) {
+    if (!value)
+        return false;
+    return /(?:^|\.)(?:formatMessage|getMessage)$/.test(value);
+}
+function isTrackCall(value) {
+    if (!value)
+        return false;
+    return /(?:^|\.)(?:trackEvent|track)$/.test(value);
+}
+function isDirectCallArgument(content, tokenStart, tokenEnd) {
+    const open = nearestEnclosingCallOpen(content, tokenStart);
+    if (open < 0)
+        return false;
+    const prefix = content.slice(open + 1, tokenStart);
+    if (prefix.trim() && !/^[\s,]*\.\.\.$/.test(prefix))
+        return false;
+    for (let index = tokenEnd; index < content.length; index++) {
+        const char = content[index];
+        if (char === ',')
+            return true;
+        if (char === ')')
+            return true;
+        if (/\S/.test(char))
+            return false;
+    }
+    return false;
+}
+function nearestEnclosingCallOpen(content, tokenStart) {
+    let depth = 0;
+    for (let index = tokenStart - 1; index >= 0; index--) {
+        const char = content[index];
+        if (char === ')')
+            depth++;
+        else if (char === '(') {
+            if (depth > 0) {
+                depth--;
+                continue;
+            }
+            return index;
+        }
+        else if (char === ';' && depth === 0)
+            return -1;
+    }
+    return -1;
+}
+function checkRegisteredTerm(token, context) {
+    const relative = toPosix(path.relative(context.projectRoot, context.file));
+    const tags = tagsForFile(relative, context.config.tagMatchMap, context.projectRoot);
+    if (!tags.length)
+        return [];
+    const registeredTags = context.dictionary.terms.get(token.value);
+    if (!registeredTags) {
+        return [createIssue(context, token, 'javascript', 'not-registered', `词条【${token.value}】未在平台登记`)];
+    }
+    if (!tags.some((tag) => registeredTags.has(tag))) {
+        return [createIssue(context, token, 'javascript', 'tag-mismatch', `词条【${token.value}】标签不匹配`)];
+    }
+    return [];
+}
+function tagsForFile(relativeFile, tagMatchMap, projectRoot) {
+    for (const [pattern, tags] of Object.entries(tagMatchMap)) {
+        if (matchesGlob(relativeFile, pattern, projectRoot))
+            return tags;
+    }
+    return [];
+}
+function createIssue(context, token, language, type, message) {
+    return {
+        type,
+        file: toPosix(path.relative(context.projectRoot, context.file)),
+        line: token.line,
+        column: token.column,
+        term: token.value,
+        message,
+        language,
+    };
+}
+function createRawIssue(context, position, term, language, type, message) {
+    return {
+        type,
+        file: toPosix(path.relative(context.projectRoot, context.file)),
+        line: position.line,
+        column: position.column,
+        term,
+        message,
+        language,
+    };
+}
+function positionAt(content, offset) {
+    let line = 1;
+    let lineStart = 0;
+    for (let index = 0; index < offset; index++) {
+        if (content[index] === '\n') {
+            line++;
+            lineStart = index + 1;
+        }
+    }
+    return { line, column: offset - lineStart + 1 };
+}
+function extensionOf(file) {
+    return path.extname(file).toLowerCase();
+}
+function extensionAllowsMarkup(extension) {
+    return extension === '.jsx' || extension === '.tsx' || extension === '.vue';
+}
+function decodeHtmlEntities(value) {
+    return value
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function normalizeSpace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function deduplicate(issues) {
+    const seen = new Set();
+    return issues.filter((issue) => {
+        const key = `${issue.file}:${issue.line}:${issue.column}:${issue.type}:${issue.term}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function toPosix(value) {
+    return value.replace(/\\/g, '/');
+}
+function normalizeGlob(value) {
+    const normalized = toPosix(value).replace(/^\.\//, '');
+    return normalized.endsWith('/') ? normalized : `${normalized}/`;
+}
+export function matchesAny(file, patterns, root) {
+    return patterns.some((pattern) => matchesGlob(file, pattern, root));
+}
+export function matchesGlob(file, patternInput, root) {
+    let pattern = normalizeGlobPattern(patternInput, root);
+    if (!pattern)
+        return false;
+    if (pattern.endsWith('/'))
+        pattern += '**';
+    return expandBraces(pattern).some((candidate) => {
+        const regex = new RegExp(`^${globToRegex(candidate)}$`, 'i');
+        return regex.test(file);
+    });
+}
+function normalizeGlobPattern(pattern, root) {
+    let value = toPosix(pattern).replace(/^\.\//, '');
+    if (path.isAbsolute(value) && root)
+        value = toPosix(path.relative(root, value));
+    if (value.startsWith('./'))
+        value = value.slice(2);
+    return value;
+}
+function expandBraces(pattern) {
+    const open = pattern.indexOf('{');
+    if (open < 0)
+        return [pattern];
+    let depth = 0;
+    let close = -1;
+    for (let index = open; index < pattern.length; index++) {
+        if (pattern[index] === '{')
+            depth++;
+        else if (pattern[index] === '}') {
+            depth--;
+            if (depth === 0) {
+                close = index;
+                break;
+            }
+        }
+    }
+    if (close < 0)
+        return [pattern];
+    const before = pattern.slice(0, open);
+    const after = pattern.slice(close + 1);
+    return pattern.slice(open + 1, close)
+        .split(',')
+        .flatMap((part) => expandBraces(`${before}${part}${after}`));
+}
+function globToRegex(pattern) {
+    let output = '';
+    for (let index = 0; index < pattern.length; index++) {
+        const char = pattern[index];
+        if (char === '*' && pattern[index + 1] === '*') {
+            if (pattern[index + 2] === '/') {
+                output += '(?:.*/)?';
+                index += 2;
+            }
+            else {
+                output += '.*';
+                index++;
+            }
+        }
+        else if (char === '*')
+            output += '[^/]*';
+        else if (char === '?')
+            output += '[^/]';
+        else
+            output += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+    }
+    return output;
+}
+//# sourceMappingURL=i18n-scanner.js.map