☰

MAL日本語アニメタイトル翻訳

My Anime Listサイト内にあるアニメのタイトルや漫画のタイトルやキャラクター名や声優名を日本語に翻訳します。

// ==UserScript==
// @name         MAL日本語アニメタイトル翻訳
// @namespace    torokesou
// @version      1.0
// @description  My Anime Listサイト内にあるアニメのタイトルや漫画のタイトルやキャラクター名や声優名を日本語に翻訳します。
// @author       torokesou
// @icon         https://files.catbox.moe/dgwc5b.png
// @license      MIT
// @match        https://myanimelist.net/*
// @grant        GM_setValue
// @grant        GM_getValue
// ==/UserScript==

(function() {
    'use strict';

    const CONFIG = {
        DELAY_MIN: 500,
        DELAY_MAX: 1500,
        SIMILARITY_THRESHOLD: 0.7,
        MIN_TEXT_LENGTH: 4,
        MAX_CACHE_SIZE: 5000,
        MAX_MEMORY_CACHE_SIZE: 1000,
        STORAGE_KEY: 'mal_japanese_titles',
        BATCH_SAVE_INTERVAL: 30000,
        REFRESH_INTERVAL: 24 * 60 * 60 * 1000,
    };

    const titleCache = new Map();
    let persistentTitles = new Map();
    let unsavedChanges = new Map();
    const processedElements = new WeakSet();
    const processingElements = new WeakSet();

    async function loadPersistentData() {
        try {
            const savedData = GM_getValue(CONFIG.STORAGE_KEY, '{}');
            const parsed = JSON.parse(savedData);
            persistentTitles = new Map(Object.entries(parsed));

            let count = 0;
            for (const [url, title] of persistentTitles) {
                if (count >= CONFIG.MAX_MEMORY_CACHE_SIZE) break;
                titleCache.set(url, title);
                count++;
            }
        } catch (error) {
            persistentTitles = new Map();
        }
    }

    function manageMemoryCache() {
        if (titleCache.size > CONFIG.MAX_MEMORY_CACHE_SIZE) {
            const excess = titleCache.size - CONFIG.MAX_MEMORY_CACHE_SIZE;
            const keysToDelete = Array.from(titleCache.keys()).slice(0, excess);
            keysToDelete.forEach(key => titleCache.delete(key));
        }
    }

    function savePersistentData() {
        if (unsavedChanges.size === 0) return;

        try {
            for (const [url, data] of unsavedChanges) {
                if (data === null) {
                    persistentTitles.delete(url);
                } else {
                    persistentTitles.set(url, data);
                }
            }

            if (persistentTitles.size > CONFIG.MAX_CACHE_SIZE) {
                const excess = persistentTitles.size - CONFIG.MAX_CACHE_SIZE;
                const keysToDelete = Array.from(persistentTitles.keys()).slice(0, excess);
                keysToDelete.forEach(key => persistentTitles.delete(key));
            }

            const dataToSave = Object.fromEntries(persistentTitles);
            GM_setValue(CONFIG.STORAGE_KEY, JSON.stringify(dataToSave));
            unsavedChanges.clear();
        } catch (error) {
            // Silent error handling
        }
    }

    setInterval(savePersistentData, CONFIG.BATCH_SAVE_INTERVAL);
    window.addEventListener('beforeunload', savePersistentData);

    function extractContentNameFromUrl(url) {
        const animeMatch = url.match(/\/anime\/\d+\/([^\/\?#]+)/);
        const mangaMatch = url.match(/\/manga\/\d+\/([^\/\?#]+)/);
        const peopleMatch = url.match(/\/people\/\d+\/([^\/\?#]+)/);
        const characterMatch = url.match(/\/character\/\d+\/([^\/\?#]+)/);
        return animeMatch ? animeMatch[1] : (mangaMatch ? mangaMatch[1] : (peopleMatch ? peopleMatch[1] : (characterMatch ? characterMatch[1] : null)));
    }

    function getContentType(url) {
        if (url.includes('/anime/')) return 'anime';
        if (url.includes('/manga/')) return 'manga';
        if (url.includes('/people/')) return 'people';
        if (url.includes('/character/')) return 'character';
        return null;
    }

    function normalizeText(text) {
        return text
            .toLowerCase()
            .replace(/[^\w\s]/g, '')
            .replace(/\s+/g, '_')
            .replace(/_+/g, '_')
            .replace(/^_|_$/g, '');
    }

    function containsJapanese(text) {
        return /[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]/.test(text);
    }

    function isPeopleName(text, url) {
        if (!url.includes('/people/')) return false;
        
        const trimmedText = text.trim();
        const westernNamePattern = /^[A-Za-z][A-Za-z\s\-'\.]*,\s*[A-Za-z][A-Za-z\s\-'\.]*$/;
        if (westernNamePattern.test(trimmedText)) {
            return true;
        }
        
        const singleNamePattern = /^[A-Za-z][A-Za-z\s\-'\.]*$/;
        if (singleNamePattern.test(trimmedText) && trimmedText.length > 2) {
            const peopleNameFromUrl = extractContentNameFromUrl(url);
            if (peopleNameFromUrl) {
                const normalizedText = normalizeText(trimmedText);
                const normalizedUrlName = normalizeText(peopleNameFromUrl.replace(/_/g, ' '));
                if (normalizedText === normalizedUrlName || normalizedUrlName.includes(normalizedText)) {
                    return true;
                }
            }
        }
        
        return false;
    }

    function isCharacterName(text, url) {
        if (!url.includes('/character/')) return false;
        
        const trimmedText = text.trim();
        const characterNamePattern = /^[A-Za-z][A-Za-z\s\-'\.]*,\s*[A-Za-z][A-Za-z\s\-'\.]*$/;
        if (characterNamePattern.test(trimmedText)) {
            return true;
        }
        
        const singleNamePattern = /^[A-Za-z][A-Za-z\s\-'\.]*$/;
        if (singleNamePattern.test(trimmedText) && trimmedText.length > 2) {
            const characterNameFromUrl = extractContentNameFromUrl(url);
            if (characterNameFromUrl) {
                const normalizedText = normalizeText(trimmedText);
                const normalizedUrlName = normalizeText(characterNameFromUrl.replace(/_/g, ' '));
                if (normalizedText === normalizedUrlName || normalizedUrlName.includes(normalizedText)) {
                    return true;
                }
            }
        }
        
        return false;
    }

    function isContentTitle(text, url) {
        const contentType = getContentType(url);
        
        if (contentType === 'people') {
            return isPeopleName(text, url);
        } else if (contentType === 'character') {
            return isCharacterName(text, url);
        }
        
        const contentNameFromUrl = extractContentNameFromUrl(url);
        
        if (!contentNameFromUrl || !contentType) {
            return false;
        }

        const normalizedText = normalizeText(text);
        const normalizedUrlName = normalizeText(contentNameFromUrl.replace(/_/g, ' '));

        const subPagePattern = contentType === 'anime' 
            ? /\/anime\/\d+\/[^\/]+\/(video|review|stats|characters|staff|news|forum|clubs|pics|episode|stacks|userrecs|featured)/
            : /\/manga\/\d+\/[^\/]+\/(review|stats|characters|staff|news|forum|clubs|pics|chapter|stacks|userrecs|featured)/;
        
        if (url.match(subPagePattern)) {
            return false;
        }

        if (normalizedText === normalizedUrlName) {
            return true;
        }

        const textIncludesUrl = normalizedText.length > 0 && normalizedUrlName.includes(normalizedText);
        const urlIncludesText = normalizedUrlName.length > 0 && normalizedText.includes(normalizedUrlName);

        if (textIncludesUrl || urlIncludesText) {
            if (normalizedText.length < CONFIG.MIN_TEXT_LENGTH) {
                return false;
            }
            return true;
        }

        const textWords = normalizedText.split('_').filter(w => w.length > 1);
        const urlWords = normalizedUrlName.split('_').filter(w => w.length > 1);

        if (textWords.length === 0 || urlWords.length === 0) {
            return false;
        }

        const commonWords = textWords.filter(word =>
            urlWords.some(urlWord => {
                return word === urlWord ||
                       (word.length >= 4 && urlWord.length >= 4 &&
                        (word.includes(urlWord) || urlWord.includes(word)));
            })
        );

        if (commonWords.length < 2 && textWords.length > 1) {
            return false;
        }

        const similarity_ratio = commonWords.length / Math.min(textWords.length, urlWords.length);
        return similarity_ratio >= CONFIG.SIMILARITY_THRESHOLD;
    }

    function isDataStale(data) {
        if (!data || typeof data !== 'object' || !data.timestamp) {
            return true;
        }
        return (Date.now() - data.timestamp) > CONFIG.REFRESH_INTERVAL;
    }

    async function getJapaneseTitle(contentUrl, retryCount = 0) {
        const maxRetries = 3;

        if (titleCache.has(contentUrl)) {
            const cached = titleCache.get(contentUrl);
            if (cached && !isDataStale(cached)) {
                return cached.title;
            }
        }

        try {
            const response = await fetch(contentUrl, {
                headers: {
                    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
                    "accept-language": "ja",
                    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
                    "cache-control": "no-cache",
                    "pragma": "no-cache",
                    "sec-fetch-dest": "document",
                    "sec-fetch-mode": "navigate",
                    "sec-fetch-site": "same-origin",
                    "upgrade-insecure-requests": "1"
                },
                mode: "cors",
                credentials: "include"
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

            const html = await response.text();
            let japaneseTitle = null;

            try {
                const parser = new DOMParser();
                const doc = parser.parseFromString(html, 'text/html');

                if (contentUrl.includes('/character/')) {
                    const h2Elements = doc.querySelectorAll('h2');
                    for (const h2 of h2Elements) {
                        const smallElement = h2.querySelector('small');
                        if (smallElement) {
                            const smallText = smallElement.textContent.trim();
                            const japaneseMatch = smallText.match(/^\(([^)]+)\)$/);
                            if (japaneseMatch && japaneseMatch[1]) {
                                const extractedName = japaneseMatch[1].trim();
                                if (extractedName && extractedName.length > 0) {
                                    japaneseTitle = extractedName;
                                    break;
                                }
                            }
                        }
                    }

                    if (!japaneseTitle) {
                        const characterPatterns = [
                            /<small>\(([^)]+)\)<\/small>/g,
                            /<small[^>]*>\(([^)]+)\)<\/small>/g,
                            /font-weight:\s*normal[^>]*>\s*<small>\(([^)]+)\)<\/small>/g
                        ];
                        
                        for (const pattern of characterPatterns) {
                            pattern.lastIndex = 0;
                            const match = pattern.exec(html);
                            if (match && match[1]) {
                                const extractedName = match[1].trim();
                                if (extractedName && extractedName.length > 0 && !extractedName.includes('<')) {
                                    japaneseTitle = extractedName;
                                    break;
                                }
                            }
                        }
                    }
                }
                else if (contentUrl.includes('/people/')) {
                    let givenName = '';
                    let familyName = '';

                    const darkTextSpans = doc.querySelectorAll('span.dark_text');
                    for (const span of darkTextSpans) {
                        const label = span.textContent.trim();
                        
                        if (label === 'Given name:') {
                            let nextNode = span.nextSibling;
                            while (nextNode && nextNode.nodeType !== Node.TEXT_NODE) {
                                nextNode = nextNode.nextSibling;
                            }
                            if (nextNode && nextNode.textContent) {
                                const text = nextNode.textContent.trim();
                                if (text && text.length > 0 && text.length < 50 && !text.includes('<')) {
                                    givenName = text;
                                }
                            }
                            
                            if (!givenName && span.parentElement) {
                                const parentText = span.parentElement.textContent;
                                const afterLabel = parentText.split('Given name:')[1];
                                if (afterLabel) {
                                    const cleanText = afterLabel.trim();
                                    if (cleanText && cleanText.length < 50 && !cleanText.includes('<')) {
                                        givenName = cleanText;
                                    }
                                }
                            }
                        } else if (label === 'Family name:') {
                            let nextNode = span.nextSibling;
                            while (nextNode && nextNode.nodeType !== Node.TEXT_NODE && nextNode.nodeType !== Node.ELEMENT_NODE) {
                                nextNode = nextNode.nextSibling;
                            }
                            
                            if (nextNode && nextNode.nodeType === Node.TEXT_NODE && nextNode.textContent) {
                                const text = nextNode.textContent.trim();
                                if (text && text.length > 0 && text.length < 30 && !text.includes('<') && !text.includes('div')) {
                                    familyName = text;
                                }
                            }
                            else if (nextNode && nextNode.nodeType === Node.ELEMENT_NODE && nextNode.tagName === 'DIV') {
                                familyName = '';
                            }
                        }
                    }

                    if (!givenName || (familyName === null)) {
                        const givenPatterns = [
                            /Given name:<\/span>\s*([^\n<>]{1,50}?)(?=\s*<\/div>)/g,
                            /Given name:<\/span>\s*([^\n<>]{1,50}?)\s*<\/div>/g,
                            /"dark_text">Given name:<\/span>\s*([^\n<>]{1,50}?)(?=\s*<)/g
                        ];
                        
                        const familyPatterns = [
                            /Family name:<\/span>\s*([^\n<>]{0,30}?)(?=\s*<div)/g,
                            /Family name:<\/span>\s*([^\n<>]{0,30}?)\s*<div/g,
                            /"dark_text">Family name:<\/span>\s*([^\n<>]{0,30}?)(?=\s*<)/g
                        ];
                        
                        if (!givenName) {
                            for (const pattern of givenPatterns) {
                                pattern.lastIndex = 0;
                                const match = pattern.exec(html);
                                if (match && match[1]) {
                                    const text = match[1].trim();
                                    if (text && !text.includes('Alternate') && !text.includes('Birthday')) {
                                        givenName = text;
                                        break;
                                    }
                                }
                            }
                        }
                        
                        if (familyName === null) {
                            for (const pattern of familyPatterns) {
                                pattern.lastIndex = 0;
                                const match = pattern.exec(html);
                                if (match) {
                                    const text = match[1] ? match[1].trim() : '';
                                    if (!text || (text.length > 0 && text.length < 30 && 
                                        !text.includes('Alternate') && !text.includes('Birthday') && 
                                        !text.includes('Website') && !text.includes('Member'))) {
                                        familyName = text;
                                        break;
                                    }
                                }
                            }
                        }
                    }

                    if (givenName && (givenName.includes('Given name:') || givenName.includes('Alternate') || givenName.includes('Birthday'))) {
                        givenName = givenName.replace('Given name:', '').trim();
                        if (givenName.includes('Alternate') || givenName.includes('Birthday') || givenName.length > 50) {
                            givenName = '';
                        }
                    }
                    
                    if (familyName && (familyName.includes('Family name:') || familyName.includes('Given name:') || 
                        familyName.includes('Alternate') || familyName.includes('Birthday'))) {
                        familyName = '';
                    }

                    if (familyName && givenName) {
                        japaneseTitle = `${familyName} ${givenName}`;
                    } else if (givenName) {
                        japaneseTitle = givenName;
                    }
                } else {
                    const japaneseElements = doc.querySelectorAll('span');
                    for (const element of japaneseElements) {
                        if (element.textContent.trim() === 'Japanese:') {
                            const parent = element.parentElement;
                            if (parent) {
                                const textContent = parent.textContent.replace('Japanese:', '').trim();
                                if (textContent && textContent !== '') {
                                    japaneseTitle = textContent;
                                    break;
                                }
                            }
                        }
                    }

                    if (!japaneseTitle) {
                        const japaneseMatch = html.match(/<span[^>]*>Japanese:<\/span>\s*([^<]+)/);
                        if (japaneseMatch && japaneseMatch[1] && japaneseMatch[1].trim()) {
                            japaneseTitle = japaneseMatch[1].trim();
                        }
                    }

                    if (!japaneseTitle) {
                        const flexibleMatch = html.match(/Japanese:<\/span>\s*([^\n<]+)/);
                        if (flexibleMatch && flexibleMatch[1] && flexibleMatch[1].trim()) {
                            japaneseTitle = flexibleMatch[1].trim();
                        }
                    }
                }
            } catch (parseError) {
                // Silent error handling
            }

            const dataToStore = {
                title: japaneseTitle,
                timestamp: Date.now()
            };

            titleCache.set(contentUrl, dataToStore);
            unsavedChanges.set(contentUrl, dataToStore);
            manageMemoryCache();

            return japaneseTitle;

        } catch (error) {
            if (retryCount < maxRetries) {
                const delay = 1000 * Math.pow(2, retryCount);
                await new Promise(resolve => setTimeout(resolve, delay));
                return getJapaneseTitle(contentUrl, retryCount + 1);
            }

            const failData = { title: null, timestamp: Date.now() };
            titleCache.set(contentUrl, failData);
            unsavedChanges.set(contentUrl, failData);
            return null;
        }
    }

    function isValidJapaneseTitle(text, originalText, contentType) {
        if (!text || text.trim() === '') return false;
        
        if (containsJapanese(text)) return true;
        
        if (contentType === 'people') {
            if (originalText && text !== originalText) {
                const isOriginalWesternFormat = /^[A-Za-z\s\-'\.]+,\s*[A-Za-z\s\-'\.]+$/.test(originalText.trim());
                const isNewJapaneseFormat = !/,/.test(text.trim()) && text.length > 2;
                
                if (isOriginalWesternFormat && isNewJapaneseFormat) {
                    return true;
                }
            }
        } else if (contentType === 'character') {
            if (originalText && text !== originalText) {
                const isOriginalWesternFormat = /^[A-Za-z\s\-'\.]+,\s*[A-Za-z\s\-'\.]+$/.test(originalText.trim());
                const isNewFormat = text.length > 2 && !/,/.test(text.trim());
                
                if (isOriginalWesternFormat && isNewFormat) {
                    return true;
                }
            }
        } else {
            if (originalText && text !== originalText) {
                const normalizedOriginal = normalizeText(originalText);
                const normalizedNew = normalizeText(text);
                
                if (normalizedNew !== normalizedOriginal && text.length > 2) {
                    return true;
                }
            }
        }
        
        return false;
    }

    function applyStoredTitle(linkElement, targetElement, contentUrl) {
        const storedData = persistentTitles.get(contentUrl);
        if (storedData) {
            const title = typeof storedData === 'string' ? storedData : storedData.title;
            const originalText = targetElement.textContent.trim();
            const contentType = getContentType(contentUrl);
            
            if (title && isValidJapaneseTitle(title, originalText, contentType)) {
                targetElement.textContent = title;
                linkElement.setAttribute('title', title);
                linkElement.setAttribute('data-stored-applied', 'true');
                return true;
            }
        }
        return false;
    }

    async function processContentLink(linkElement) {
        if (processedElements.has(linkElement) || processingElements.has(linkElement)) {
            return;
        }

        processingElements.add(linkElement);

        try {
            const href = linkElement.getAttribute('href');
            if (!href || (!href.includes('/anime/') && !href.includes('/manga/') && !href.includes('/people/') && !href.includes('/character/'))) {
                return;
            }

            let textContent = '';
            let targetElement = null;

            const strongElement = linkElement.querySelector('strong');
            if (strongElement && strongElement.children.length === 0) {
                textContent = strongElement.textContent.trim();
                targetElement = strongElement;
            }
            else {
                const titleSpan = linkElement.querySelector('span.title');
                if (titleSpan && titleSpan.children.length === 0) {
                    textContent = titleSpan.textContent.trim();
                    targetElement = titleSpan;
                }
                else if (linkElement.children.length === 0) {
                    textContent = linkElement.textContent.trim();
                    targetElement = linkElement;
                }
                else if (linkElement.children.length === 1 && linkElement.children[0].tagName === 'STRONG') {
                    textContent = linkElement.textContent.trim();
                    targetElement = linkElement.children[0];
                }
            }

            if (!textContent) {
                return;
            }

            if (!isContentTitle(textContent, href)) {
                return;
            }

            const fullUrl = href.startsWith('http') ? href : `https://myanimelist.net${href}`;
            const appliedStored = applyStoredTitle(linkElement, targetElement, fullUrl);
            const storedData = persistentTitles.get(fullUrl);
            const shouldRefetch = !appliedStored || isDataStale(storedData);

            if (shouldRefetch) {
                try {
                    await new Promise(resolve =>
                        setTimeout(resolve, Math.random() * (CONFIG.DELAY_MAX - CONFIG.DELAY_MIN) + CONFIG.DELAY_MIN)
                    );

                    const originalText = targetElement.textContent.trim();
                    const japaneseTitle = await getJapaneseTitle(fullUrl);
                    const contentType = getContentType(fullUrl);
                    
                    if (japaneseTitle && targetElement && isValidJapaneseTitle(japaneseTitle, originalText, contentType)) {
                        targetElement.textContent = japaneseTitle;
                        linkElement.setAttribute('title', japaneseTitle);
                    }
                } catch (error) {
                    // Silent error handling
                }
            }

            processedElements.add(linkElement);
        } finally {
            processingElements.delete(linkElement);
        }
    }

    function findAndProcessContentLinks() {
        const selectors = [
            'a.hoverinfo_trigger[href*="/anime/"]:not([data-processed])',
            'a[href*="/anime/"] strong:not([data-processed])',
            '.title a[href*="/anime/"]:not([data-processed])',
            '.picSurround + a[href*="/anime/"]:not([data-processed])',
            'a[href*="/anime/"] span.title:not([data-processed])',
            'a[href*="/anime/"]:not([data-processed]):not([href*="/anime.php"]):not([href*="/clubs"]):not([href*="/reviews"])',
            'a.hoverinfo_trigger[href*="/manga/"]:not([data-processed])',
            'a[href*="/manga/"] strong:not([data-processed])',
            '.title a[href*="/manga/"]:not([data-processed])',
            '.picSurround + a[href*="/manga/"]:not([data-processed])',
            'a[href*="/manga/"] span.title:not([data-processed])',
            'a[href*="/manga/"]:not([data-processed]):not([href*="/manga.php"]):not([href*="/clubs"]):not([href*="/reviews"])',
            'a[href*="/people/"]:not([data-processed])',
            'a[href*="/character/"]:not([data-processed])'
        ];

        selectors.forEach(selector => {
            const elements = document.querySelectorAll(selector);

            elements.forEach(async (element) => {
                let linkElement = element;
                if (element.tagName === 'STRONG' || (element.tagName === 'SPAN' && element.classList.contains('title'))) {
                    linkElement = element.closest('a[href*="/anime/"], a[href*="/manga/"], a[href*="/people/"], a[href*="/character/"]');
                }

                if (!linkElement || linkElement.getAttribute('data-processed')) {
                    return;
                }

                linkElement.setAttribute('data-processed', 'true');
                await processContentLink(linkElement);
            });
        });
    }

    async function initialize() {
        await loadPersistentData();
        setTimeout(findAndProcessContentLinks, 100);
        setTimeout(findAndProcessContentLinks, 1000);
    }

    const observer = new MutationObserver((mutations) => {
        let shouldProcess = false;

        mutations.forEach((mutation) => {
            if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
                for (const node of mutation.addedNodes) {
                    if (node.nodeType === Node.ELEMENT_NODE) {
                        const hasContentLinks = node.querySelectorAll && 
                            (node.querySelectorAll('a[href*="/anime/"]').length > 0 ||
                             node.querySelectorAll('a[href*="/manga/"]').length > 0 ||
                             node.querySelectorAll('a[href*="/people/"]').length > 0 ||
                             node.querySelectorAll('a[href*="/character/"]').length > 0);
                        if (hasContentLinks || 
                            (node.tagName === 'A' && node.href && 
                             (node.href.includes('/anime/') || node.href.includes('/manga/') || 
                              node.href.includes('/people/') || node.href.includes('/character/')))) {
                            shouldProcess = true;
                            break;
                        }
                    }
                }
            }
        });

        if (shouldProcess) {
            setTimeout(findAndProcessContentLinks, 500);
        }
    });

    observer.observe(document.body, {
        childList: true,
        subtree: true
    });

    let currentUrl = window.location.href;
    
    window.addEventListener('popstate', () => {
        setTimeout(findAndProcessContentLinks, 1000);
    });

    setInterval(() => {
        if (window.location.href !== currentUrl) {
            currentUrl = window.location.href;
            setTimeout(findAndProcessContentLinks, 1000);
        }
    }, 5000);

    initialize();

})();