news media journalism

English

The domain name 'quaint-silver-wfpg99jz2s-4r312qxvp7.edgeone.app' uses the application-focused generic top-level domain (.app) with subdomain 'quaint-silver-wfpg99jz2s-4r312qxvp7'. The second-level label 'edgeone' is 7 characters long with four vowels and 3 consonants. Segmentation suggests two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/a9/eb/a9eb3df9-2bb7-4290-8426-5bfad61142bf.html.gz

eb31e4370fa76f10e0d6c67d27673dfa03d7031c60e91f8bfb7fd7ee845b9315

width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no

viewport

html/a9/eb/a9eb3df9-2bb7-4290-8426-5bfad61142bf_nodriver.html.gz

Happy Holi Mishu

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


        // --- CONFIGURATION ---
        const BG_COLOR = '#fdfbf7';
        const COLORS = [
            '#FF007F', '#FFD700', '#00FFFF', '#32CD32', 
            '#FF4500', '#8A2BE2', '#FF1493', '#00BFFF'
        ];

        // --- CONTEXT SETUP ---
        const textCanvas = document.getElementById('text-layer');
        const textCtx = textCanvas.getContext('2d');
        const splashCanvas = document.getElementById('splash-layer');
        const splashCtx = splashCanvas.getContext('2d');

        // Animation State
        let particles = []; 
        let width, height;

        // --- RESIZE LOGIC ---
        function resize() {
            width = window.innerWidth;
            height = window.innerHeight;
            const pxRatio = window.devicePixelRatio || 1;

            [textCanvas, splashCanvas].forEach(c => {
                c.width = width * pxRatio;
                c.height = height * pxRatio;
                c.style.width = width + 'px';
                c.style.height = height + 'px';
                c.getContext('2d').scale(pxRatio, pxRatio);
            });

            initHiddenText();
        }

        function initHiddenText() {
            // Clear and reset composite mode
            textCtx.globalCompositeOperation = 'source-over';
            textCtx.clearRect(0, 0, width, height);

            // Font Settings - Reduced slightly to 0.15 to fit 3 lines comfortably
            const fontSize = Math.min(width, height) * 0.15;
            const lineHeight = fontSize * 1.1; // Space between lines

            textCtx.font = `900 ${fontSize}px "Arial Black", "Impact", sans-serif`;
            textCtx.textAlign = 'center';
            textCtx.textBaseline = 'middle';
            
            // Draw Invisible Text (Same color as BG)
            textCtx.fillStyle = BG_COLOR; 
            
            // --- DRAWING THE 3 LINES ---
            // 1. HAPPY (Top)
            textCtx.fillText("HAPPY", width / 2, height / 2 - lineHeight);
            
            // 2. HOLI (Middle - Exact Center)
            textCtx.fillText("HOLI", width / 2, height / 2);
            
            // 3. MISHU (Bottom)
            textCtx.fillText("MISHU", width / 2, height / 2 + lineHeight);

            // Set Masking Mode for future draws
            textCtx.globalCompositeOperation = 'source-atop';
        }

        // --- GEOMETRY GENERATION ---
        function createSplashGeometry(x, y, color) {
            const baseRadius = 30 + Math.random() * 40;
            
            // 1. Generate Main Blob Points
            const points = [];
            const numPoints = 12;
            const step = (Math.PI * 2) / numPoints;
            for (let i = 0; i <= numPoints; i++) {
                const angle = i * step;
                const r = baseRadius * (0.8 + Math.random() * 0.4); 
                points.push({
                    dx: Math.cos(angle) * r, 
                    dy: Math.sin(angle) * r
                });
            }

            // 2. Generate Droplets
            const droplets = [];
            const numDrops = 4 + Math.floor(Math.random() * 4);
            for(let i=0; i<numDrops; i++) {
                const angle = Math.random() * Math.PI * 2;
                const dist = baseRadius * (1.1 + Math.random() * 0.5);
                droplets.push({
                    dx: Math.cos(angle) * dist,
                    dy: Math.sin(angle) * dist,
                    r: baseRadius * (0.05 + Math.random() * 0.15),
                    vx: Math.cos(angle) * 1.5,
                    vy: Math.sin(angle) * 1.5
                });
            }

            return { x, y, color, points, droplets, life: 1.0, scale: 0.1 };
        }

        // --- DRAWING FUNCTION ---
        function renderSplash(ctx, splash) {
            ctx.fillStyle = splash.color;
            ctx.beginPath();

            // Draw Main Blob
            const first = splash.points[0];
            ctx.moveTo(splash.x + first.dx * splash.scale, splash.y + first.dy * splash.scale);

            for (let i = 0; i < splash.points.length - 1; i++) {
                const p1 = splash.points[i];
                const p2 = splash.points[i + 1];
                
                const p1x = splash.x + p1.dx * splash.scale;
                const p1y = splash.y + p1.dy * splash.scale;
                
                const p2x = splash.x + p2.dx * splash.scale;
                const p2y = splash.y + p2.dy * splash.scale;

                const midX = (p1x + p2x) / 2;
                const midY = (p1y + p2y) / 2;

                ctx.quadraticCurveTo(p1x, p1y, midX, midY);
            }
            
            const last = splash.points[splash.points.length - 1];
            const start = splash.points[0];
            const lx = splash.x + last.dx * splash.scale;
            const ly = splash.y + last.dy * splash.scale;
            const sx = splash.x + start.dx * splash.scale;
            const sy = splash.y + start.dy * splash.scale;
            
            ctx.quadraticCurveTo(lx, ly, sx, sy);
            ctx.fill();

            // Draw Droplets
            const movement = (1.0 - splash.life) * 20; 

            splash.droplets.forEach(d => {
                ctx.beginPath();
                const dX = splash.x + (d.dx * splash.scale) + (d.vx * movement);
                const dY = splash.y + (d.dy * splash.scale) + (d.vy * movement);
                ctx.arc(dX, dY, d.r * splash.scale, 0, Math.PI * 2);
                ctx.fill();
            });
        }

        // --- INTERACTION ---
        function handleInput(e) {
            const clientX = e.touches ? e.touches[0].clientX : e.clientX;
            const clientY = e.touches ? e.touches[0].clientY : e.clientY;

            const color = COLORS[Math.floor(Math.random() * COLORS.length)];

            // Create geometry
            const splashData = createSplashGeometry(clientX, clientY, color);

            // 1. Draw PERMANENTLY on text layer
            const permanentSplash = { ...splashData, scale: 1.0, life: 1.0 }; 
            // Zero out droplet velocity for permanent stamp
            permanentSplash.droplets = permanentSplash.droplets.map(d => ({...d, vx:0, vy:0}));
            renderSplash(textCtx, permanentSplash);
            
            // 2. Add to transient animation loop
            splashData.scale = 0.5; 
            particles.push(splashData);
        }

        // --- ANIMATION LOOP ---
        function animate() {
            splashCtx.clearRect(0, 0, width, height);

            for (let i = 0; i < particles.length; i++) {
                const p = particles[i];

                p.life -= 0.015; // Fade speed
                if(p.scale < 1.1) p.scale += 0.08; 

                if (p.life > 0) {
                    splashCtx.globalAlpha = p.life;
                    renderSplash(splashCtx, p);
                }
            }

            particles = particles.filter(p => p.life > 0);
            
            splashCtx.globalAlpha = 1.0;
            requestAnimationFrame(animate);
        }

        // --- EVENTS ---
        window.addEventListener('resize', resize);
        window.addEventListener('mousedown', handleInput);
        window.addEventListener('touchstart', (e) => {
            e.preventDefault();
            handleInput(e);
        }, { passive: false });

        // Init
        resize();
        animate();

    

✅ Low Risk - https://quaint-silver-wfpg99jz2s-4r312qxvp7.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
2	43.152.26.58	Singapore	AS139341ACE
2	1	-	-

Security Scan Report: quaint-silver-wfpg99jz2s-4r312qxvp7.edgeone.app

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

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