technology software

documentation technical

government public service

healthcare medical

news media journalism

English

You're looking at domain 'csvr.pages.dev' on the developer-focused generic top-level domain (.dev) and includes subdomain 'csvr'. Count 5 characters in 'pages' containing two vowels alongside 3 consonants. It segments into 1 word: pages. No strong language cues emerged from the frequency lists.

html/8c/00/8c00a76a-bf3d-470a-bba3-0bb7b6e8ad50.html.gz

f38d583fe44a65f45c3fbe0d4ea875cc5b3e72e7e3b82a227ef6ec224eaf2e2c

35d3612aa2c1bab84c23e25839d00d565610740106b8f18a4edd163bab276062

viewport

Abuse Team

CloudFlare, Inc.

pages.dev

Cloudflare Abuse Contact

MNT-CLOUDFLARE

Cloudflare Technical Contact

CLOUDFLARENET-EU


    // Global state variables
    let tableData = [];
    let originalData = []; 
    let tableHeaders = [];
    const tableContainer = document.getElementById('tableContainer');
    const sortSection = document.getElementById('sort-section');
    const sortColumnSelect = document.getElementById('sortColumn');
    const similarityRange = document.getElementById('similarityRange');
    const similarityValueSpan = document.getElementById('similarityValue');
    const searchTermInput = document.getElementById('searchTerm'); // New input reference

    let rowIdCounter = 0; 
    
    // Event listener to update the displayed similarity value
    similarityRange.addEventListener('input', () => {
        similarityValueSpan.textContent = similarityRange.value + '%';
    });


    // --- CSV Parsing Function (Now adds a unique ID) ---
    function parseCSV(text) {
        const lines = text.split('\n').filter(line => line.trim() !== '');
        if (lines.length === 0) return { headers: [], data: [] };

        const cleanValue = (val) => {
            let cleaned = val ? val.trim() : '';
            if (cleaned.startsWith('"') && cleaned.endsWith('"')) {
                cleaned = cleaned.substring(1, cleaned.length - 1);
            }
            return cleaned;
        };

        const headers = lines[0].split(',').map(cleanValue);
        const data = [];

        for (let i = 1; i < lines.length; i++) {
            const values = lines[i].match(/(?:"[^"]*"|[^,])+/g); 
            
            if (!values) continue;

            const row = {};
            
            headers.forEach((header, index) => {
                const rawValue = values[index];
                row[header] = cleanValue(rawValue);
            });
            // CRITICAL: Add a unique ID to each row
            row._id = rowIdCounter++;
            data.push(row);
        }
        return { headers, data };
    }

    // --- File Input Handler ---
    document.getElementById('csvFile').addEventListener('change', (event) => {
        const file = event.target.files[0];
        if (!file) return;

        const reader = new FileReader();
        reader.onload = (e) => {
            const csvText = e.target.result;
            const parsed = parseCSV(csvText);
            
            tableHeaders = parsed.headers;
            tableData = parsed.data;
            originalData = JSON.parse(JSON.stringify(parsed.data)); 

            if (tableData.length > 0) {
                tableContainer.innerHTML = ''; 
                const tableHtml = renderTable(tableData);
                tableContainer.insertAdjacentHTML('beforeend', tableHtml);
                
                populateSortOptions();
                sortSection.style.display = 'flex';
            } else {
                tableContainer.innerHTML = '<p style="text-align: center; color: red;">The CSV file is empty or could not be parsed.</p>';
                sortSection.style.display = 'none';
            }
        };
        reader.readAsText(file);
    });
    
    // --- Table Rendering Function (Returns HTML string) ---
    function renderTable(data, sortCol = null, sortDir = null) {
        if (data.length === 0) {
            return '<p style="text-align: center; color: #6c757d;">No data to display.</p>';
        }

        let html = '<table><thead><tr>';
        
        // Render Headers
        tableHeaders.forEach(header => {
            if (header === '_id') return;

            let iconClass = 'unsorted';
            if (header === sortCol) {
                iconClass = sortDir;
            }

            html += `<th onclick="sortTable('${header}')" data-column="${header}">
                        ${header}
                        <span class="sort-icon ${iconClass}"></span>
                    </th>`;
        });
        html += '</tr></thead><tbody>';

        // Render Data Rows
        data.forEach(row => {
            html += '<tr>';
            tableHeaders.forEach(header => {
                if (header !== '_id') {
                    html += `<td>${row[header] || ''}</td>`;
                }
            });
            html += '</tr>';
        });

        html += '</tbody></table>';
        return html;
    }

    // --- Populate Sort Column Dropdown ---
    function populateSortOptions() {
        sortColumnSelect.innerHTML = ''; 
        tableHeaders.forEach(header => {
            if (header !== '_id') { 
                const option = document.createElement('option');
                option.value = header;
                option.textContent = header;
                sortColumnSelect.appendChild(option);
            }
        });
    }

    // --- Helper function for Alphanumeric Sorting ---
    function alphanumericSortComparator(a, b) {
        if (!a && !b) return 0;
        if (!a) return -1;
        if (!b) return 1;
        return String(a).localeCompare(String(b), undefined, { numeric: true, sensitivity: 'base' });
    }

    // --- Standard Sort Function (Alphanumeric) ---
    let currentSort = { column: null, direction: 'asc' };

    function sortTable(column) {
        const newDirection = (currentSort.column === column && currentSort.direction === 'asc') ? 'desc' : 'asc';

        tableData.sort((a, b) => {
            const valA = String(a[column] || '');
            const valB = String(b[column] || '');
            
            let comparison = alphanumericSortComparator(valA, valB);
            
            return newDirection === 'asc' ? comparison : -comparison;
        });

        currentSort = { column: column, direction: newDirection };
        
        // Clear and render the table
        tableContainer.innerHTML = '';
        const tableHtml = renderTable(tableData, currentSort.column, currentSort.direction);
        tableContainer.insertAdjacentHTML('beforeend', tableHtml);
    }

    // ------------------------------------------------------------------
    // --- NEW FUZZY SEARCH/SORT LOGIC ---
    // ------------------------------------------------------------------
    function applyFuzzySearch() {
        if (tableData.length === 0) {
            alert('Please load a CSV file first.');
            return;
        }

        const searchTerm = searchTermInput.value.trim();
        if (!searchTerm) {
            alert('Please enter a search term for fuzzy search.');
            return;
        }
        
        const column = sortColumnSelect.value;
        const similarityPercent = parseInt(similarityRange.value);
        const THRESHOLD = (100 - similarityPercent) / 100; 

        const fuseOptions = {
            keys: [column], 
            includeScore: true, // Needed to sort by similarity
            ignoreLocation: true,
            threshold: THRESHOLD,
            id: '_id' 
        };

        const fuse = new Fuse(tableData, fuseOptions);
        const results = fuse.search(searchTerm);

        // 1. Matched items (already sorted by Fuse.js score - best match first)
        const matchedItems = results.map(result => result.item);

        // 2. Unmatched items (items not meeting the threshold)
        const matchedSet = new Set(matchedItems.map(item => item._id));
        const unmatchedItems = tableData.filter(item => !matchedSet.has(item._id));

        // 3. Combine them: Matched (Fuzzy Sorted) first, then Unmatched (original order)
        const finalSortedData = [...matchedItems, ...unmatchedItems];
        tableData = finalSortedData;

        // --- Rendering the Fuzzy Search Data ---
        tableContainer.innerHTML = ''; 
        const messageHtml = `
            <div class="cluster-message" style="background-color:#d4edda; border-color:#c3e6cb; color:#155724;">
                Sort applied to column: <strong>${column}</strong> using term: <strong>"${searchTerm}"</strong> with **${similarityPercent}%** threshold.
            </div>
        `;
        tableContainer.insertAdjacentHTML('beforeend', messageHtml);
        const tableHtml = renderTable(tableData);
        tableContainer.insertAdjacentHTML('beforeend', tableHtml);

        currentSort = { column: null, direction: null }; 
    }
    // ------------------------------------------------------------------
    
    // --- FUZZY CLUSTERING LOGIC ---
    function applyFuzzyClustering() {
        if (tableData.length === 0) {
            alert('Please load a CSV file first.');
            return;
        }
        
        const column = sortColumnSelect.value;
        const similarityPercent = parseInt(similarityRange.value);
        const THRESHOLD = (100 - similarityPercent) / 100; 
        
        const fuseOptions = {
            keys: [column], 
            includeScore: true,
            ignoreLocation: true,
            threshold: THRESHOLD,
            id: '_id'
        };

        const itemMap = new Map(tableData.map(item => [item._id, item]));
        let unclusteredIds = new Set(tableData.map(item => item._id));
        let clusteredData = [];

        // --- Greedy Clustering Algorithm ---
        while (unclusteredIds.size > 0) {
            const [referenceId] = unclusteredIds; 
            unclusteredIds.delete(referenceId); 
            const referenceItem = itemMap.get(referenceId);
            const searchTerm = referenceItem[column];

            const fuse = new Fuse(tableData, fuseOptions);
            const results = fuse.search(searchTerm);
            
            let cluster = [referenceItem];
            
            results.forEach(result => {
                const itemId = result.item._id;
                
                if (unclusteredIds.has(itemId)) {
                    cluster.push(itemMap.get(itemId));
                    unclusteredIds.delete(itemId);
                }
            });

            clusteredData.push(...cluster);
        }

        tableData = clusteredData;
        
        // --- Rendering the Clustered Data ---
        tableContainer.innerHTML = ''; 
        const messageHtml = `
            <div class="cluster-message">
                sorted column: <strong>${column}</strong> with a **${similarityPercent}%** similarity threshold.
            </div>
        `;
        tableContainer.insertAdjacentHTML('beforeend', messageHtml);
        const tableHtml = renderTable(tableData);
        tableContainer.insertAdjacentHTML('beforeend', tableHtml);
        
        currentSort = { column: null, direction: null }; 
    }


    // --- Reset Function ---
    function resetTable() {
        tableData = JSON.parse(JSON.stringify(originalData)); 
        if (tableData.length > 0) {
            tableContainer.innerHTML = ''; 
            const tableHtml = renderTable(tableData);
            tableContainer.insertAdjacentHTML('beforeend', tableHtml);
            currentSort = { column: null, direction: 'asc' };
            searchTermInput.value = ''; // Clear the search field on reset
        }
    }
    function simSort(){ 
          const sv= searchTermInput.value;
          
        if(sv.trim() ===''){
          
          applyFuzzyClustering();
          }else{
               applyFuzzySearch();
               }
          }
        // --- DOWNLOAD FUNCTION ---
    function downloadCSV() {
        if (tableData.length === 0) {
            alert("No data to download.");
            return;
        }

        // 1. Get headers (excluding internal _id)
        const headers = tableHeaders.filter(header => header !== '_id');
        const headerRow = headers.join(',') + '\n';

        // 2. Map data rows to CSV strings
        const dataRows = tableData.map(row => {
            return headers.map(header => {
                let value = row[header] || '';
                
                // Escape value by wrapping in double quotes if it contains a comma, quote, or newline
                if (/[,"\n]/.test(value)) {
                    // Escape internal double quotes by doubling them (" becomes "")
                    value = value.replace(/"/g, '""');
                    value = `"${value}"`;
                }
                return value;
            }).join(',');
        }).join('\n');

        const csvContent = headerRow + dataRows;

        // 3. Create a Blob and trigger the download
        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
        const link = document.createElement("a");
        const url = URL.createObjectURL(blob);

        link.setAttribute("href", url);
        link.setAttribute("download", "sorted_data.csv");
        link.style.visibility = 'hidden';

        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
    }



Requests	IP Address	Location	AS Autonomous System
3	188.114.97.3	United States	AS13335Cloudflare, Inc.
1	104.16.175.226	United States	AS13335Cloudflare, Inc.
1	142.251.127.95	United States	AS15169Google LLC
5	3	-	-

Security Scan Report: csvr.pages.dev

Summary

AI Security Verdict

Low Risk

Risk Factors

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