technology software

government public service

education learning

documentation technical

healthcare medical

Russian

The domain name 'nodmsk.maxononline.ru' uses the Russian country-code top-level domain (.ru); it also runs on subdomain 'nodmsk'. Count 11 characters in 'maxononline' containing 5 vowels alongside six consonants. Breaking it apart gives 3 words: max, on, online. Median word length is three characters. No strong language cues emerged from the frequency lists.

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

0544978cbe65f5aab6baea60c45621ab4852ccb5567f432223631dd708c1da18

viewport

MAXONONLINE.RU

Abuse contact role object

RocketCloud Team

DMPN-MNT

Aleksandr Borisov

ORG-NCC1-RIPE

RocketCloud


        // DOM элементы
        const fileInput = document.getElementById('fileInput');
        const fileNameSpan = document.getElementById('fileName');
        const convertBtn = document.getElementById('convertBtn');
        const statusMsg = document.getElementById('statusMsg');
        const previewBox = document.getElementById('previewBox');
        const previewContent = document.getElementById('previewContent');
        const charCountSpan = document.getElementById('charCount');
        const outputFormatSelect = document.getElementById('outputFormat');
        const csvDelimiterItem = document.getElementById('csvDelimiterItem');
        const csvDelimiterSelect = document.getElementById('csvDelimiter');
        
        let currentFileContent = null;
        let currentFileName = '';
        let currentFileRaw = null; // ArrayBuffer для кодировок

        // Показать статус
        function showStatus(message, type = 'info') {
            statusMsg.textContent = message;
            statusMsg.style.display = 'block';
            statusMsg.className = 'status-text';
            if (type === 'success') statusMsg.classList.add('status-success');
            else if (type === 'error') statusMsg.classList.add('status-error');
            else statusMsg.classList.add('status-info');
            
            setTimeout(() => {
                if (statusMsg.textContent === message) {
                    statusMsg.style.display = 'none';
                }
            }, 4000);
        }

        // Декодирование файла с выбранной кодировкой
        async function decodeFileContent(arrayBuffer, encoding) {
            let decoder;
            switch(encoding) {
                case 'windows1251':
                    // Windows-1251 декодер через TextDecoder
                    decoder = new TextDecoder('windows-1251');
                    break;
                case 'ascii':
                    decoder = new TextDecoder('ascii');
                    break;
                default:
                    decoder = new TextDecoder('utf-8');
            }
            return decoder.decode(arrayBuffer);
        }

        // Обработка выбранного файла
        async function handleFile(file) {
            if (!file) return;
            
            // Проверка размера (макс 5 MB для предпросмотра)
            if (file.size > 5 * 1024 * 1024) {
                showStatus('Файл слишком большой (макс 5 МБ для конвертации)', 'error');
                return;
            }
            
            currentFileName = file.name;
            fileNameSpan.textContent = `📄 ${file.name} (${(file.size / 1024).toFixed(1)} KB)`;
            
            // Читаем как ArrayBuffer для поддержки разных кодировок
            const arrayBuffer = await file.arrayBuffer();
            currentFileRaw = arrayBuffer;
            
            // Декодируем выбранной кодировкой (по умолчанию UTF-8)
            const encoding = document.querySelector('input[name="encoding"]:checked').value;
            try {
                currentFileContent = await decodeFileContent(arrayBuffer, encoding);
                
                // Показываем предпросмотр (первые 500 символов)
                const preview = currentFileContent.length > 500 
                    ? currentFileContent.substring(0, 500) + '...' 
                    : currentFileContent;
                previewContent.textContent = preview;
                charCountSpan.textContent = `${currentFileContent.length} символов`;
                previewBox.style.display = 'block';
                
                convertBtn.disabled = false;
                showStatus('Файл загружен. Выберите формат и нажмите "Конвертировать".', 'success');
            } catch (e) {
                console.error(e);
                showStatus('Ошибка чтения файла: возможно, неверная кодировка', 'error');
                convertBtn.disabled = true;
                previewBox.style.display = 'none';
                currentFileContent = null;
            }
        }

        // Показать/скрыть настройки CSV в зависимости от формата
        function toggleCsvSettings() {
            const format = outputFormatSelect.value;
            if (format === 'csv') {
                csvDelimiterItem.style.display = 'flex';
            } else {
                csvDelimiterItem.style.display = 'none';
            }
        }
        
        outputFormatSelect.addEventListener('change', toggleCsvSettings);
        toggleCsvSettings();

        // Конвертация в разные форматы
        function convertToFormat(content, format, options = {}) {
            switch(format) {
                case 'txt':
                    return content;
                    
                case 'csv':
                    const delimiter = options.delimiter || ',';
                    // Преобразуем текст в CSV: разбиваем на строки, каждую строку в кавычки
                    const lines = content.split(/\r?\n/);
                    const csvRows = lines.map(line => {
                        // Экранируем кавычки и оборачиваем в двойные кавычки
                        const escaped = line.replace(/"/g, '""');
                        return `"${escaped}"`;
                    });
                    return csvRows.join('\n');
                    
                case 'json':
                    // Создаём JSON объект: исходный текст как строка или разбиваем по строкам
                    try {
                        // Пробуем распарсить как JSON, если это валидный JSON
                        JSON.parse(content);
                        return JSON.stringify(JSON.parse(content), null, 2);
                    } catch(e) {
                        // Обычный текст -> объект с метаданными
                        const jsonObj = {
                            filename: currentFileName || 'document',
                            content: content,
                            lines: content.split(/\r?\n/),
                            charCount: content.length,
                            lineCount: content.split(/\r?\n/).length,
                            convertedAt: new Date().toISOString()
                        };
                        return JSON.stringify(jsonObj, null, 2);
                    }
                    
                case 'html':
                    // Экранируем HTML спецсимволы
                    const escapeHtml = (str) => {
                        return str.replace(/[&<>]/g, function(m) {
                            if (m === '&') return '&amp;';
                            if (m === '<') return '&lt;';
                            if (m === '>') return '&gt;';
                            return m;
                        }).replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, function(c) {
                            return c;
                        });
                    };
                    const escapedContent = escapeHtml(content);
                    const htmlTemplate = `<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Конвертированный документ - ${escapeHtml(currentFileName || 'text')}</title>
    <style>
        body { font-family: monospace; background: #1e1e1e; color: #d4d4d4; padding: 2rem; line-height: 1.5; }
        pre { background: #2d2d2d; padding: 1rem; border-radius: 8px; overflow-x: auto; white-space: pre-wrap; }
    </style>
</head>
<body>
    <h1>${escapeHtml(currentFileName || 'Текстовый документ')}</h1>
    <pre>${escapedContent}</pre>
    <hr><small>Сконвертировано TXT Converter</small>
</body>
</html>`;
                    return htmlTemplate;
                    
                case 'xml':
                    const escapeXml = (str) => {
                        return str.replace(/[&<>]/g, function(m) {
                            if (m === '&') return '&amp;';
                            if (m === '<') return '&lt;';
                            if (m === '>') return '&gt;';
                            return m;
                        });
                    };
                    const linesArray = content.split(/\r?\n/);
                    let xmlContent = '<?xml version="1.0" encoding="UTF-8"?>\n<document>\n';
                    xmlContent += `  <meta>\n    <filename>${escapeXml(currentFileName || 'unknown')}</filename>\n    <date>${new Date().toISOString()}</date>\n  </meta>\n`;
                    xmlContent += `  <content>\n`;
                    for(let i = 0; i < linesArray.length; i++) {
                        xmlContent += `    <line line="${i+1}">${escapeXml(linesArray[i])}</line>\n`;
                    }
                    xmlContent += `  </content>\n</document>`;
                    return xmlContent;
                    
                case 'md':
                    // Markdown: просто обрамляем в блок кода или оставляем как есть
                    return `# Конвертированный документ\n\n**Исходный файл:** ${currentFileName || 'text.txt'}\n\n\`\`\`text\n${content}\n\`\`\``;
                    
                default:
                    return content;
            }
        }

        // Скачать результат
        function downloadFile(content, format, originalName) {
            let mimeType = 'text/plain';
            let extension = format;
            
            switch(format) {
                case 'txt': mimeType = 'text/plain'; extension = 'txt'; break;
                case 'csv': mimeType = 'text/csv'; extension = 'csv'; break;
                case 'json': mimeType = 'application/json'; extension = 'json'; break;
                case 'html': mimeType = 'text/html'; extension = 'html'; break;
                case 'xml': mimeType = 'application/xml'; extension = 'xml'; break;
                case 'md': mimeType = 'text/markdown'; extension = 'md'; break;
                default: mimeType = 'text/plain'; extension = 'txt';
            }
            
            // Кириллица в имени файла
            let baseName = originalName ? originalName.replace(/\.[^/.]+$/, '') : 'document';
            baseName = baseName.replace(/[^\wа-яё\-]/gi, '_');
            const fileName = `${baseName}.${extension}`;
            
            // Используем Blob с правильной кодировкой UTF-8
            const blob = new Blob([content], { type: `${mimeType};charset=utf-8` });
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = fileName;
            document.body.appendChild(a);
            a.click();
            document.body.removeChild(a);
            URL.revokeObjectURL(url);
        }

        // Основная конвертация
        async function performConversion() {
            if (!currentFileContent && currentFileRaw) {
                // Если контент не загружен, пробуем декодировать заново с текущей кодировкой
                const encoding = document.querySelector('input[name="encoding"]:checked').value;
                try {
                    currentFileContent = await decodeFileContent(currentFileRaw, encoding);
                } catch(e) {
                    showStatus('Ошибка декодирования файла', 'error');
                    return;
                }
            }
            
            if (!currentFileContent) {
                showStatus('Нет загруженного файла', 'error');
                return;
            }
            
            const format = outputFormatSelect.value;
            let delimiter = ',';
            if (format === 'csv') {
                delimiter = csvDelimiterSelect.value;
                if (delimiter === '\\t') delimiter = '\t';
            }
            
            convertBtn.disabled = true;
            const originalBtnText = convertBtn.textContent;
            convertBtn.textContent = '⏳ Конвертация...';
            
            try {
                // Имитация небольшой задержки для UX (асинхронная конвертация мгновенна)
                await new Promise(resolve => setTimeout(resolve, 50));
                const converted = convertToFormat(currentFileContent, format, { delimiter });
                
                // Проверка размера результата (предупреждение если > 10MB)
                if (converted.length > 10 * 1024 * 1024) {
                    showStatus('Созданный файл больше 10 МБ, скачивание может быть медленным', 'info');
                }
                
                downloadFile(converted, format, currentFileName);
                showStatus(`✅ Готово! Файл сохранён в формате ${format.toUpperCase()}`, 'success');
            } catch (err) {
                console.error(err);
                showStatus(`Ошибка конвертации: ${err.message}`, 'error');
            } finally {
                convertBtn.disabled = false;
                convertBtn.textContent = originalBtnText;
            }
        }

        // Обработчики событий
        fileInput.addEventListener('change', (e) => {
            if (e.target.files.length) {
                handleFile(e.target.files[0]);
            }
        });
        
        // Drag & Drop
        const dropZone = document.getElementById('fileDropZone');
        dropZone.addEventListener('dragover', (e) => {
            e.preventDefault();
            dropZone.style.borderColor = 'var(--accent-blue)';
        });
        dropZone.addEventListener('dragleave', () => {
            dropZone.style.borderColor = 'var(--border-color)';
        });
        dropZone.addEventListener('drop', async (e) => {
            e.preventDefault();
            dropZone.style.borderColor = 'var(--border-color)';
            const files = e.dataTransfer.files;
            if (files.length && files[0]) {
                await handleFile(files[0]);
                // Visual feedback
                fileInput.files = files;
            } else {
                showStatus('Пожалуйста, перетащите текстовый файл (.txt, .md, .csv и т.д.)', 'error');
            }
        });
        
        convertBtn.addEventListener('click', performConversion);
        
        // Смена кодировки: перезагружаем предпросмотр
        const encodingRadios = document.querySelectorAll('input[name="encoding"]');
        encodingRadios.forEach(radio => {
            radio.addEventListener('change', async () => {
                if (currentFileRaw) {
                    const encoding = document.querySelector('input[name="encoding"]:checked').value;
                    try {
                        currentFileContent = await decodeFileContent(currentFileRaw, encoding);
                        const preview = currentFileContent.length > 500 
                            ? currentFileContent.substring(0, 500) + '...' 
                            : currentFileContent;
                        previewContent.textContent = preview;
                        charCountSpan.textContent = `${currentFileContent.length} символов`;
                        showStatus(`Кодировка изменена на ${encoding === 'utf8' ? 'UTF-8' : encoding === 'windows1251' ? 'Windows-1251' : 'ASCII'}`, 'info');
                    } catch(e) {
                        showStatus('Ошибка декодирования с выбранной кодировкой', 'error');
                    }
                }
            });
        });
        
        // При загрузке страницы показываем подсказку
        showStatus('Загрузите TXT файл для конвертации в другие форматы', 'info');
    

Requests	IP Address	Location	AS Autonomous System
3	142.251.20.94	United States	AS15169Google LLC
2	94.232.42.106	Kyrgyzstan	AS64439IT Outsourcing LLC
2	142.251.110.95	United States	AS15169Google LLC
7	3	-	-

Security Scan Report: nodmsk.maxononline.ru

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies1

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History