government public service

news media journalism

adult content

documentation technical

English

You're looking at domain 'unknown-magenta-kkjyp9eaim-gi9npc7ekz.edgeone.app' on the application-focused generic top-level domain (.app) with subdomain 'unknown-magenta-kkjyp9eaim-gi9npc7ekz'. The second-level label 'edgeone' is 7 characters long holding four vowels versus three consonants. Tokenizing the label suggests two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/5a/2b/5a2b827e-08b8-416a-b1e4-c2286fae5b91.html.gz

a790ad0d65a38f4da31c74543dee0452c8cd31eb9ae2e4136ce5742c4d222271

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

viewport

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

html/5a/2b/5a2b827e-08b8-416a-b1e4-c2286fae5b91_nodriver.html.gz

unknown-magenta-kkjyp9eaim-gi9npc7ekz.edgeone.app

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


    /**
     * Happy Spaceship - Pure JS Game Engine
     */
    const canvas = document.getElementById('gameCanvas');
    const ctx = canvas.getContext('2d');
    const overlay = document.getElementById('overlay');
    const startBtn = document.getElementById('startBtn');
    const title = document.getElementById('title');
    const finalStats = document.getElementById('finalStats');
    const scoreHUD = document.getElementById('currentScoreHUD');
    const highHUD = document.getElementById('highScoreHUD');

    // Game Configuration
    const CONFIG = {
        gravity: 0.25,
        thrust: -5.5,
        pipeWidth: 60,
        pipeGap: 180,
        pipeFrequency: 1500, // ms
        initialSpeed: 3,
        difficultyStep: 10,
        difficultyScale: 1.05
    };

    // Game State
    let state = {
        isRunning: false,
        score: 0,
        highScore: localStorage.getItem('happySpaceship_highScore') || 0,
        speed: CONFIG.initialSpeed,
        lastPipeTime: 0,
        pipes: [],
        stars: [],
        particles: []
    };

    let player = {
        x: 50,
        y: 0,
        radius: 15,
        velocity: 0,
        rotation: 0
    };

    // Initialization
    function init() {
        resize();
        window.addEventListener('resize', resize);
        highHUD.innerText = state.highScore;
        
        // Stars background setup
        for(let i = 0; i < 50; i++) {
            state.stars.push({
                x: Math.random() * canvas.width,
                y: Math.random() * canvas.height,
                size: Math.random() * 2,
                speed: Math.random() * 0.5 + 0.1
            });
        }

        startBtn.addEventListener('click', startGame);
        window.addEventListener('keydown', (e) => {
            if (e.code === 'Space') handleInput();
        });
        canvas.addEventListener('touchstart', (e) => {
            e.preventDefault();
            handleInput();
        });
        canvas.addEventListener('mousedown', handleInput);
    }

    function resize() {
        const container = document.getElementById('game-container');
        canvas.width = container.clientWidth;
        canvas.height = container.clientHeight;
        player.x = canvas.width * 0.25;
        player.y = canvas.height / 2;
    }

    function handleInput() {
        if (!state.isRunning) return;
        player.velocity = CONFIG.thrust;
        createParticles(player.x, player.y, '#ffaa00', 5);
    }

    function startGame() {
        state.isRunning = true;
        state.score = 0;
        state.speed = CONFIG.initialSpeed;
        state.pipes = [];
        state.particles = [];
        player.y = canvas.height / 2;
        player.velocity = 0;
        scoreHUD.innerText = '0';
        overlay.classList.add('hidden');
        
        requestAnimationFrame(gameLoop);
    }

    function gameOver() {
        state.isRunning = false;
        if (state.score > state.highScore) {
            state.highScore = state.score;
            localStorage.setItem('happySpaceship_highScore', state.highScore);
            highHUD.innerText = state.highScore;
        }

        title.innerText = "Mission Failed";
        finalStats.innerHTML = `
            <p style="font-size: 1.4rem">Score: ${state.score}</p>
            <p>High Score: ${state.highScore}</p>
        `;
        startBtn.innerText = "Restart";
        overlay.classList.remove('hidden');
    }

    function createPipe() {
        const minPipeHeight = 50;
        const spacing = canvas.height - CONFIG.pipeGap - (minPipeHeight * 2);
        const topHeight = Math.floor(Math.random() * spacing) + minPipeHeight;
        
        state.pipes.push({
            x: canvas.width,
            top: topHeight,
            passed: false
        });
    }

    function createParticles(x, y, color, count) {
        for(let i = 0; i < count; i++) {
            state.particles.push({
                x, y,
                vx: (Math.random() - 0.5) * 4,
                vy: (Math.random() - 0.5) * 4,
                life: 1.0,
                color
            });
        }
    }

    function update(deltaTime) {
        // Physics
        player.velocity += CONFIG.gravity;
        player.y += player.velocity;
        player.rotation = Math.min(Math.PI/4, Math.max(-Math.PI/4, player.velocity * 0.1));

        // Screen bounds
        if (player.y + player.radius > canvas.height || player.y - player.radius < 0) {
            gameOver();
        }

        // Background movement
        state.stars.forEach(star => {
            star.x -= star.speed;
            if (star.x < 0) star.x = canvas.width;
        });

        // Pipe spawning
        const now = Date.now();
        if (now - state.lastPipeTime > (CONFIG.pipeFrequency / (state.speed / CONFIG.initialSpeed))) {
            createPipe();
            state.lastPipeTime = now;
        }

        // Pipe logic
        for (let i = state.pipes.length - 1; i >= 0; i--) {
            let p = state.pipes[i];
            p.x -= state.speed;

            // Collision detection
            const hitTop = player.x + player.radius > p.x && 
                           player.x - player.radius < p.x + CONFIG.pipeWidth &&
                           player.y - player.radius < p.top;
            
            const hitBottom = player.x + player.radius > p.x && 
                              player.x - player.radius < p.x + CONFIG.pipeWidth &&
                              player.y + player.radius > p.top + CONFIG.pipeGap;

            if (hitTop || hitBottom) {
                createParticles(player.x, player.y, '#ff0000', 20);
                gameOver();
            }

            // Scoring
            if (!p.passed && p.x + CONFIG.pipeWidth < player.x) {
                p.passed = true;
                state.score++;
                scoreHUD.innerText = state.score;
                
                // Difficulty scaling
                if (state.score % CONFIG.difficultyStep === 0) {
                    state.speed *= CONFIG.difficultyScale;
                }
            }

            // Cleanup
            if (p.x + CONFIG.pipeWidth < 0) {
                state.pipes.splice(i, 1);
            }
        }

        // Particles
        for (let i = state.particles.length - 1; i >= 0; i--) {
            let p = state.particles[i];
            p.x += p.vx;
            p.y += p.vy;
            p.life -= 0.02;
            if (p.life <= 0) state.particles.splice(i, 1);
        }
    }

    function draw() {
        ctx.clearRect(0, 0, canvas.width, canvas.height);

        // Draw Stars
        ctx.fillStyle = "white";
        state.stars.forEach(star => {
            ctx.beginPath();
            ctx.arc(star.x, star.y, star.size, 0, Math.PI * 2);
            ctx.fill();
        });

        // Draw Pipes
        state.pipes.forEach(p => {
            const grad = ctx.createLinearGradient(p.x, 0, p.x + CONFIG.pipeWidth, 0);
            grad.addColorStop(0, '#2c3e50');
            grad.addColorStop(0.5, '#bdc3c7');
            grad.addColorStop(1, '#2c3e50');
            
            ctx.fillStyle = grad;
            // Top pipe
            ctx.fillRect(p.x, 0, CONFIG.pipeWidth, p.top);
            // Bottom pipe
            ctx.fillRect(p.x, p.top + CONFIG.pipeGap, CONFIG.pipeWidth, canvas.height);
            
            // Pipe caps
            ctx.fillStyle = "#00f2ff";
            ctx.fillRect(p.x - 5, p.top - 10, CONFIG.pipeWidth + 10, 10);
            ctx.fillRect(p.x - 5, p.top + CONFIG.pipeGap, CONFIG.pipeWidth + 10, 10);
        });

        // Draw Particles
        state.particles.forEach(p => {
            ctx.globalAlpha = p.life;
            ctx.fillStyle = p.color;
            ctx.fillRect(p.x, p.y, 3, 3);
        });
        ctx.globalAlpha = 1.0;

        // Draw Player (Spaceship)
        ctx.save();
        ctx.translate(player.x, player.y);
        ctx.rotate(player.rotation);
        
        // Ship Body
        ctx.fillStyle = '#eee';
        ctx.beginPath();
        ctx.moveTo(20, 0);
        ctx.lineTo(-10, -15);
        ctx.lineTo(-5, 0);
        ctx.lineTo(-10, 15);
        ctx.closePath();
        ctx.fill();

        // Cockpit
        ctx.fillStyle = '#00f2ff';
        ctx.beginPath();
        ctx.arc(5, 0, 5, 0, Math.PI * 2);
        ctx.fill();

        // Thruster flame
        if (state.isRunning) {
            ctx.fillStyle = Math.random() > 0.5 ? '#ff4400' : '#ffaa00';
            ctx.beginPath();
            ctx.moveTo(-7, 0);
            ctx.lineTo(-18 - (Math.random() * 10), 0);
            ctx.stroke();
        }

        ctx.restore();
    }

    function gameLoop() {
        if (!state.isRunning) return;
        update();
        draw();
        requestAnimationFrame(gameLoop);
    }

    // Run
    init();



✅ Low Risk - https://unknown-magenta-kkjyp9eaim-gi9npc7ekz.edgeone.app/

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

Security Scan Report: unknown-magenta-kkjyp9eaim-gi9npc7ekz.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