entertainment media

documentation technical

English

You're looking at domain 'choirpal.pages.dev' on the developer-focused generic top-level domain (.dev); it also runs on subdomain 'choirpal'. The registrable portion 'pages' spans 5 characters with 2 vowels and three consonants. Splitting it apart reveals one word: pages. Average segment length settles at five characters. No strong language cues emerged from the frequency lists.

html/c5/41/c5414909-ab9a-43ed-833d-e62f46846b73.html.gz

acc7e41455a80765b5fd9c7ee1b8078a6d160bbbca455aeae854de65c947d59e

511739665a39c0738f0de14e2ea2f3e15dd4471cbcd6d262e64ebe70f88db583

viewport

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


        // State
        let tracks = [];
        let existingConcerts = null;
        let draggedElement = null;
        
        // DOM Elements
        const dropZone = document.getElementById('dropZone');
        const fileInput = document.getElementById('fileInput');
        const tracksContainer = document.getElementById('tracksContainer');
        const tracksList = document.getElementById('tracksList');
        const concertNameInput = document.getElementById('concertName');
        const concertLocationInput = document.getElementById('concertLocation');
        const concertDateInput = document.getElementById('concertDate');
        const existingConcertsFile = document.getElementById('existingConcertsFile');
        const generateBtn = document.getElementById('generateBtn');
        
        // Drag and Drop
        dropZone.addEventListener('click', () => fileInput.click());
        
        dropZone.addEventListener('dragover', (e) => {
            e.preventDefault();
            dropZone.classList.add('drag-over');
        });
        
        dropZone.addEventListener('dragleave', () => {
            dropZone.classList.remove('drag-over');
        });
        
        dropZone.addEventListener('drop', (e) => {
            e.preventDefault();
            dropZone.classList.remove('drag-over');
            handleFiles(e.dataTransfer.files);
        });
        
        fileInput.addEventListener('change', (e) => {
            handleFiles(e.target.files);
        });
        
        // Handle uploaded files
        function handleFiles(files) {
            const newTracks = Array.from(files).map(file => {
                const parsed = parseFileName(file.name);
                return {
                    file: file,
                    originalName: file.name,
                    concertName: parsed.concert,
                    songTitle: parsed.song,
                    voice: parsed.voice,
                    multiVoiceEnabled: true
                };
            });
            
            tracks.push(...newTracks);
            
            // Auto-fill concert name from first track if empty
            if (!concertNameInput.value && newTracks.length > 0) {
                concertNameInput.value = formatConcertName(newTracks[0].concertName);
            }
            
            renderTracks();
            updateGenerateButton();
        }
        
        // Parse filename: concertname_songname_voice.mp3
        function parseFileName(filename) {
            const nameWithoutExt = filename.replace(/\.(mp3|m4a|aac|wav)$/i, '');
            const parts = nameWithoutExt.split('_');
            
            if (parts.length >= 3) {
                const voice = parts[parts.length - 1];
                const song = parts.slice(1, -1).join('_');
                const concert = parts[0];
                
                return {
                    concert: concert,
                    song: song,
                    voice: voice.toLowerCase()
                };
            }
            
            return {
                concert: 'unknown',
                song: nameWithoutExt,
                voice: 'unknown'
            };
        }
        
        // Format concert name for display
        function formatConcertName(rawName) {
            return rawName
                .split('-')
                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
                .join(' ');
        }
        
        // Render tracks list
        function renderTracks() {
            if (tracks.length === 0) {
                tracksContainer.style.display = 'none';
                return;
            }
            
            tracksContainer.style.display = 'block';
            tracksList.innerHTML = '';
            
            tracks.forEach((track, index) => {
                const item = document.createElement('div');
                item.className = 'track-item';
                item.draggable = true;
                item.dataset.index = index;
                
                item.innerHTML = `
                    <div class="track-drag-handle">☰</div>
                    <div class="track-info">
                        <input type="text" 
                               class="track-title-input" 
                               value="${track.songTitle}" 
                               data-index="${index}"
                               placeholder="Song title">
                        <div class="track-voice">Voice: ${track.voice}</div>
                    </div>
                    <div class="track-mv-toggle">
                        <input type="checkbox" 
                               id="mv-${index}" 
                               data-index="${index}"
                               ${track.multiVoiceEnabled ? 'checked' : ''}>
                        <label for="mv-${index}">Multi-Voice</label>
                    </div>
                    <button class="track-remove" data-index="${index}">Remove</button>
                `;
                
                // Drag events
                item.addEventListener('dragstart', handleDragStart);
                item.addEventListener('dragover', handleDragOver);
                item.addEventListener('drop', handleDrop);
                item.addEventListener('dragend', handleDragEnd);
                
                // Title input
                const titleInput = item.querySelector('.track-title-input');
                titleInput.addEventListener('change', (e) => {
                    tracks[e.target.dataset.index].songTitle = e.target.value;
                });
                
                // MV checkbox
                const mvCheckbox = item.querySelector('input[type="checkbox"]');
                mvCheckbox.addEventListener('change', (e) => {
                    tracks[e.target.dataset.index].multiVoiceEnabled = e.target.checked;
                });
                
                // Remove button
                const removeBtn = item.querySelector('.track-remove');
                removeBtn.addEventListener('click', (e) => {
                    const idx = parseInt(e.target.dataset.index);
                    tracks.splice(idx, 1);
                    renderTracks();
                    updateGenerateButton();
                });
                
                tracksList.appendChild(item);
            });
        }
        
        // Drag and drop reordering
        function handleDragStart(e) {
            draggedElement = e.target;
            e.target.style.opacity = '0.4';
        }
        
        function handleDragOver(e) {
            if (e.preventDefault) {
                e.preventDefault();
            }
            return false;
        }
        
        function handleDrop(e) {
            if (e.stopPropagation) {
                e.stopPropagation();
            }
            
            if (draggedElement !== e.currentTarget) {
                const draggedIndex = parseInt(draggedElement.dataset.index);
                const targetIndex = parseInt(e.currentTarget.dataset.index);
                
                const temp = tracks[draggedIndex];
                tracks.splice(draggedIndex, 1);
                tracks.splice(targetIndex, 0, temp);
                
                renderTracks();
            }
            
            return false;
        }
        
        function handleDragEnd(e) {
            e.target.style.opacity = '1';
        }
        
        // Toolbar buttons
        document.getElementById('selectAllMV').addEventListener('click', () => {
            tracks.forEach(track => track.multiVoiceEnabled = true);
            renderTracks();
        });
        
        document.getElementById('clearAllMV').addEventListener('click', () => {
            tracks.forEach(track => track.multiVoiceEnabled = false);
            renderTracks();
        });
        
        document.getElementById('clearAllTracks').addEventListener('click', () => {
            if (confirm('Are you sure you want to remove all tracks?')) {
                tracks = [];
                renderTracks();
                updateGenerateButton();
            }
        });
        
        // Load existing concerts.json
        existingConcertsFile.addEventListener('change', (e) => {
            const file = e.target.files[0];
            if (!file) return;
            
            const reader = new FileReader();
            reader.onload = (e) => {
                try {
                    existingConcerts = JSON.parse(e.target.result);
                    document.getElementById('existingConcertsInfo').style.display = 'block';
                    document.getElementById('existingConcertsCount').textContent = 
                        `${existingConcerts.concerts.length} existing concert(s) found`;
                } catch (error) {
                    alert('Error parsing concerts.json file: ' + error.message);
                }
            };
            reader.readAsText(file);
        });
        
        // Update generate button state
        function updateGenerateButton() {
            generateBtn.disabled = tracks.length === 0 || !concertNameInput.value.trim();
        }
        
        concertNameInput.addEventListener('input', updateGenerateButton);
        
        // Generate concert files
        generateBtn.addEventListener('click', async () => {
            if (tracks.length === 0 || !concertNameInput.value.trim()) {
                alert('Please add tracks and provide a concert name');
                return;
            }
            
            generateBtn.disabled = true;
            document.getElementById('progressContainer').style.display = 'block';
            
            try {
                const concertId = generateConcertId(concertNameInput.value);
                const concertData = await generateConcertData(concertId);
                await createDownloadableZip(concertId, concertData);
                
                document.getElementById('successBox').style.display = 'block';
                document.getElementById('successBox').scrollIntoView({ behavior: 'smooth' });
            } catch (error) {
                alert('Error generating files: ' + error.message);
                console.error(error);
            } finally {
                generateBtn.disabled = false;
            }
        });
        
        // Generate concert ID from name
        function generateConcertId(name) {
            return name.toLowerCase()
                .replace(/[^a-z0-9]+/g, '-')
                .replace(/^-+|-+$/g, '');
        }
        
        // Generate all concert data
        async function generateConcertData(concertId) {
            updateProgress(25, 'Organizing tracks...');
            
            // Group tracks by song
            const songMap = new Map();
            tracks.forEach(track => {
                if (!songMap.has(track.songTitle)) {
                    songMap.set(track.songTitle, []);
                }
                songMap.get(track.songTitle).push(track);
            });
            
            updateProgress(50, 'Generating config.json...');
            
            // Get unique voices
            const allVoices = [...new Set(tracks.map(t => t.voice))];
            
            // Create voice display names
            const voiceDisplay = {};
            allVoices.forEach(voice => {
                voiceDisplay[voice] = voice.charAt(0).toUpperCase() + voice.slice(1).toUpperCase();
            });
            
            // Create config.json
            const config = {
                title: concertNameInput.value.trim(),
                subtitle: concertLocationInput.value.trim() || "",
                date: concertDateInput.value || "",
                voices: allVoices,
                voiceDisplay: voiceDisplay,
                tracksFile: `/concerts/${concertId}/tracks.json`,
                mediaBasePath: "https://your-cdn-url.r2.dev",
                lyricsFile: ""
            };
            
            updateProgress(75, 'Generating tracks.json...');
            
            // Create tracks.json
            const voiceTracks = {};
            allVoices.forEach(voice => {
                voiceTracks[voice] = [];
            });
            
            // Add tracks for each voice
            Array.from(songMap.entries()).forEach(([songTitle, songTracks]) => {
                songTracks.forEach(track => {
                    const trackData = {
                        title: songTitle,
                        audioSrc: `/concerts/${concertId}/${track.originalName}`,
                        multiVoiceEnabled: track.multiVoiceEnabled
                    };
                    
                    voiceTracks[track.voice].push(trackData);
                });
            });
            
            const tracksJson = {
                voiceTracks: voiceTracks
            };
            
            updateProgress(90, 'Updating concerts.json...');
            
            // Create or update concerts.json
            const concertsJson = existingConcerts || { concerts: [], defaultConcert: "" };
            
            // Remove existing concert with same ID if present
            concertsJson.concerts = concertsJson.concerts.filter(c => c.id !== concertId);
            
            // Add new concert
            concertsJson.concerts.push({
                id: concertId,
                name: concertNameInput.value.trim(),
                subtitle: concertLocationInput.value.trim() || "",
                date: concertDateInput.value || "",
                status: "active",
                default: concertsJson.concerts.length === 0,
                configPath: `/concerts/${concertId}/config.json`
            });
            
            // Set default if this is the first concert
            if (!concertsJson.defaultConcert) {
                concertsJson.defaultConcert = concertId;
            }
            
            updateProgress(100, 'Complete!');
            
            return {
                concertId,
                config,
                tracks: tracksJson,
                concerts: concertsJson
            };
        }
        
        // Create downloadable ZIP
        async function createDownloadableZip(concertId, data) {
            const zip = new JSZip();
            
            // Add concerts.json to root
            zip.file('concerts.json', JSON.stringify(data.concerts, null, 2));
            
            // Create concerts folder structure
            const concertFolder = zip.folder('concerts').folder(concertId);
            concertFolder.file('config.json', JSON.stringify(data.config, null, 2));
            concertFolder.file('tracks.json', JSON.stringify(data.tracks, null, 2));
            
            // Generate ZIP
            const blob = await zip.generateAsync({ type: 'blob' });
            
            // Create download links
            const downloadLinks = document.getElementById('downloadLinks');
            downloadLinks.innerHTML = '';
            
            // Download ZIP
            const zipLink = document.createElement('a');
            zipLink.href = URL.createObjectURL(blob);
            zipLink.download = `${concertId}-config.zip`;
            zipLink.className = 'download-btn';
            zipLink.innerHTML = '📦 Download Complete Package (ZIP)';
            downloadLinks.appendChild(zipLink);
            
            // Individual JSON files
            const filesData = [
                { name: 'concerts.json', data: data.concerts },
                { name: 'config.json', data: data.config },
                { name: 'tracks.json', data: data.tracks }
            ];
            
            filesData.forEach(file => {
                const link = document.createElement('a');
                const blob = new Blob([JSON.stringify(file.data, null, 2)], { type: 'application/json' });
                link.href = URL.createObjectURL(blob);
                link.download = file.name;
                link.className = 'download-btn';
                link.innerHTML = `📄 ${file.name}`;
                downloadLinks.appendChild(link);
            });
        }
        
        // Update progress bar
        function updateProgress(percent, text) {
            const fill = document.getElementById('progressFill');
            fill.style.width = percent + '%';
            fill.textContent = text || (percent + '%');
        }
    

Requests	IP Address	Location	AS Autonomous System
2	104.17.24.14	United States	AS13335Cloudflare, Inc.
2	172.66.44.157	United States	AS13335Cloudflare, Inc.
4	2	-	-

Security Scan Report: choirpal.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 Technologies5

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