Rain

English

You're looking at domain 'weekly-olive-44a9pt9kb3-ovhokk46dt.edgeone.app' on the application-focused generic top-level domain (.app) and includes subdomain 'weekly-olive-44a9pt9kb3-ovhokk46dt'. Count 7 characters in 'edgeone' with 4 vowels and three consonants. Word splitting yields 2 words: edge, one. Median word length is 3.5 characters. No strong language cues emerged from the frequency lists.

html/72/e2/72e265e7-e20f-4d85-81b6-43c477665100.html.gz

9a1a3c8578e88b125583c4580412b9ff5c61ab47f9fbdf14ae7ed00f5ce1bb7c

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

viewport

apple-mobile-web-app-capable

apple-mobile-web-app-status-bar-style

html/72/e2/72e265e7-e20f-4d85-81b6-43c477665100_nodriver.html.gz

Prudence Malinki

MarkMonitor Inc.

edgeone.app


        // ============================================
        // RAIN: A Digital Art Experience
        // Mobile-first, silent, interactive
        // ============================================

        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        const mainText = document.getElementById('mainText');

        // Resize canvas to fit window
        function resizeCanvas() {
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
        }
        resizeCanvas();
        window.addEventListener('resize', resizeCanvas);

        // ============================================
        // STATE MANAGEMENT
        // ============================================
        const state = {
            phase: 'intro', // intro, raining, swipe, tilt, cover, reveal, replay
            raindrops: [],
            floatingWords: [],
            touchActive: false,
            touchX: 0,
            touchY: 0,
            skyAlpha: 1, // For final reveal transition
            rainIntensity: 0,
            startTime: Date.now(),
            phaseStartTime: 0,
            hasSwipedFast: false,
            hasSwipedSlow: false,
            hasSwipedCircle: false,
            hasTilted: false,
            hasCovered: false,
            coveredRegions: [],
            lastTiltX: 0,
            lastTiltY: 0,
            screenCovered: false,
            phaseInstructions: {
                'intro': "Some things don't start loudly.",
                'touch': 'Touch the screen.',
                'rain-intro': 'Rain only exists when you touch it.',
                'swipe': 'Move your finger.',
                'tilt': 'Tilt your phone.',
                'cover': 'Cover the rain with your hand.',
                'final': "It's been one month since Rain touched my days.",
                'final-sub': 'This isn\'t a question. Just a moment.',
                'replay': 'Touch again.'
            }
        };

        // ============================================
        // TEXT DISPLAY SYSTEM
        // ============================================
        function displayText(text, duration = 2000, isInstruction = false, subtext = null) {
            mainText.textContent = text;
            mainText.classList.add('visible');
            if (isInstruction) mainText.classList.add('instruction');

            setTimeout(() => {
                mainText.classList.remove('visible');
                if (isInstruction) mainText.classList.remove('instruction');
                
                if (subtext) {
                    setTimeout(() => {
                        mainText.textContent = subtext;
                        mainText.classList.add('visible');
                        setTimeout(() => mainText.classList.remove('visible'), 2000);
                    }, 300);
                }
            }, duration);
        }

        // ============================================
        // FLOATING WORDS SYSTEM
        // ============================================
        const wordsToReveal = ['Unexpected', 'Familiar', 'Comfort', 'Rain'];

        function createFloatingWord(x, y) {
            const word = wordsToReveal[Math.floor(Math.random() * wordsToReveal.length)];
            const wordEl = document.createElement('div');
            wordEl.className = 'floating-word';
            wordEl.textContent = word;
            wordEl.style.left = (x - 30) + 'px';
            wordEl.style.top = y + 'px';
            document.querySelector('.text-overlay').appendChild(wordEl);

            setTimeout(() => wordEl.classList.add('animate'), 10);
            setTimeout(() => wordEl.remove(), 2500);
        }

        // ============================================
        // RAINDROP CLASS
        // ============================================
        class Raindrop {
            constructor(x, y, vx = 0, vy = 2) {
                this.x = x;
                this.y = y;
                this.vx = vx;
                this.vy = vy;
                this.life = 1;
                this.length = Math.random() * 8 + 4;
                this.opacity = Math.random() * 0.6 + 0.3;
            }

            update(wind = 0, gravity = 1) {
                this.x += this.vx + wind;
                this.y += this.vy * gravity;
                this.life -= 0.008;
            }

            draw(ctx) {
                ctx.globalAlpha = this.opacity * this.life;
                ctx.strokeStyle = 'rgba(200, 220, 255, 0.8)';
                ctx.lineWidth = 1.5;
                ctx.lineCap = 'round';
                ctx.beginPath();
                ctx.moveTo(this.x, this.y);
                ctx.lineTo(this.x + this.vx * 3, this.y + this.vy * 3);
                ctx.stroke();
                ctx.globalAlpha = 1;
            }

            isAlive() {
                return this.life > 0 && this.y < canvas.height;
            }
        }

        // ============================================
        // RIPPLE EFFECT
        // ============================================
        class Ripple {
            constructor(x, y) {
                this.x = x;
                this.y = y;
                this.radius = 0;
                this.maxRadius = 100;
                this.life = 1;
            }

            update() {
                this.radius = (1 - this.life) * this.maxRadius;
                this.life -= 0.05;
            }

            draw(ctx) {
                if (this.life <= 0) return;
                ctx.globalAlpha = 0.3 * this.life;
                ctx.strokeStyle = 'rgba(200, 220, 255, 0.6)';
                ctx.lineWidth = 2;
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
                ctx.stroke();
                ctx.globalAlpha = 1;
            }

            isAlive() {
                return this.life > 0;
            }
        }

        // ============================================
        // DEVICE ORIENTATION HANDLING
        // ============================================
        let deviceOrientation = { alpha: 0, beta: 0, gamma: 0 };

        function handleOrientation(event) {
            deviceOrientation.alpha = event.alpha || 0;
            deviceOrientation.beta = event.beta || 0;
            deviceOrientation.gamma = event.gamma || 0;
        }

        if (typeof DeviceOrientationEvent !== 'undefined' && typeof DeviceOrientationEvent.requestPermission === 'function') {
            // iOS 13+ requires permission
            document.addEventListener('click', function requestPermission() {
                DeviceOrientationEvent.requestPermission()
                    .then(permission => {
                        if (permission === 'granted') {
                            window.addEventListener('deviceorientation', handleOrientation);
                            document.removeEventListener('click', requestPermission);
                        }
                    })
                    .catch(console.error);
            }, { once: true });
        } else {
            window.addEventListener('deviceorientation', handleOrientation);
        }

        // ============================================
        // TOUCH & SWIPE HANDLING
        // ============================================
        const touchTracker = {
            startX: 0,
            startY: 0,
            startTime: 0,
            currentX: 0,
            currentY: 0,
            isMoving: false,
            distance: 0
        };

        canvas.addEventListener('touchstart', (e) => {
            const touch = e.touches[0];
            touchTracker.startX = touch.clientX;
            touchTracker.startY = touch.clientY;
            touchTracker.currentX = touch.clientX;
            touchTracker.currentY = touch.clientY;
            touchTracker.startTime = Date.now();
            touchTracker.distance = 0;

            state.touchActive = true;
            state.touchX = touch.clientX;
            state.touchY = touch.clientY;

            // Handle different phases
            if (state.phase === 'intro') {
                transitionPhase('touch');
            }
        }, { passive: true });

        canvas.addEventListener('touchmove', (e) => {
            const touch = e.touches[0];
            const prevX = touchTracker.currentX;
            const prevY = touchTracker.currentY;
            touchTracker.currentX = touch.clientX;
            touchTracker.currentY = touch.clientY;
            touchTracker.distance += Math.hypot(touch.clientX - prevX, touch.clientY - prevY);

            state.touchX = touch.clientX;
            state.touchY = touch.clientY;
            state.touchActive = true;

            // Detect swipe gestures
            if (state.phase === 'swipe' || state.phase === 'raining') {
                detectSwipeType();
            }
        }, { passive: true });

        canvas.addEventListener('touchend', (e) => {
            state.touchActive = false;
            const duration = Date.now() - touchTracker.startTime;
            
            if (state.phase === 'swipe') {
                if (touchTracker.distance > 150 && duration < 500) {
                    // Fast swipe
                    state.hasSwipedFast = true;
                } else if (touchTracker.distance > 100 && duration > 500) {
                    // Slow swipe
                    state.hasSwipedSlow = true;
                }

                // Check if all interactions done
                if (state.hasSwipedFast && state.hasSwipedSlow && state.hasSwipedCircle) {
                    transitionPhase('tilt');
                }
            } else if (state.phase === 'replay') {
                state = {
                    ...state,
                    phase: 'intro',
                    raindrops: [],
                    floatingWords: [],
                    touchActive: false,
                    startTime: Date.now(),
                    hasSwipedFast: false,
                    hasSwipedSlow: false,
                    hasSwipedCircle: false,
                    hasTilted: false,
                    hasCovered: false,
                    coveredRegions: [],
                    screenCovered: false,
                    skyAlpha: 1
                };
                init();
            }
        }, { passive: true });

        function detectSwipeType() {
            const deltaX = touchTracker.currentX - touchTracker.startX;
            const deltaY = touchTracker.currentY - touchTracker.startY;
            const angle = Math.atan2(deltaY, deltaX);

            // Simple circular motion detection
            if (touchTracker.distance > 150 && !state.hasSwipedCircle) {
                state.hasSwipedCircle = true;
            }
        }

        // ============================================
        // LIGHT SENSOR (SCREEN COVER DETECTION)
        // ============================================
        if ('AmbientLightSensor' in window) {
            try {
                const sensor = new AmbientLightSensor();
                let previousLight = 100;

                sensor.addEventListener('reading', () => {
                    const drop = Math.abs(sensor.illuminance - previousLight);
                    if (drop > 30 && state.phase === 'cover') {
                        state.screenCovered = true;
                        displayText('You didn\'t stop it.', 1500);
                        setTimeout(() => {
                            displayText('You just made space.', 1500);
                        }, 1700);
                    }
                    previousLight = sensor.illuminance;
                });
                sensor.start();
            } catch (e) {
                console.log('Ambient light sensor not available');
            }
        }

        // ============================================
        // PHASE TRANSITIONS
        // ============================================
        function transitionPhase(newPhase) {
            state.phase = newPhase;
            state.phaseStartTime = Date.now();

            switch (newPhase) {
                case 'touch':
                    displayText('Rain only exists when you touch it.', 2000, true);
                    setTimeout(() => transitionPhase('swipe'), 2500);
                    break;

                case 'swipe':
                    displayText('Move your finger.', 1500, true);
                    setTimeout(() => {
                        displayText('Slow. Fast. Circular.', 1500, true);
                    }, 1800);
                    break;

                case 'tilt':
                    displayText('Tilt your phone.', 1500, true);
                    break;

                case 'cover':
                    displayText('Cover the rain with your hand.', 1500, true);
                    break;

                case 'reveal':
                    state.skyAlpha = 1;
                    setTimeout(() => {
                        displayText('It\'s been one month since Rain touched my days.', 2500);
                        setTimeout(() => {
                            displayText('This isn\'t a question.', 1500, false);
                            setTimeout(() => {
                                displayText('Just a moment.', 1500, false);
                                setTimeout(() => transitionPhase('replay'), 2000);
                            }, 1700);
                        }, 3200);
                    }, 3000);
                    break;

                case 'replay':
                    displayText('Touch again.', 2000, true);
                    break;
            }
        }

        // ============================================
        // ANIMATION LOOP
        // ============================================
        function animate() {
            const now = Date.now();
            const elapsed = (now - state.startTime) / 1000;

            // Clear canvas with gradient
            const gradient = ctx.createLinearGradient(0, 0, 0, canvas.height);
            
            if (state.phase === 'reveal') {
                state.skyAlpha = Math.max(0, state.skyAlpha - 0.01);
                gradient.addColorStop(0, `rgba(30, 40, 60, ${0.8 * state.skyAlpha})`);
                gradient.addColorStop(1, `rgba(60, 80, 100, ${0.6 * state.skyAlpha})`);
            } else if (state.phase === 'intro') {
                gradient.addColorStop(0, 'rgba(20, 30, 50, 1)');
                gradient.addColorStop(1, 'rgba(50, 60, 80, 1)');
            } else {
                gradient.addColorStop(0, 'rgba(15, 25, 40, 1)');
                gradient.addColorStop(1, 'rgba(40, 50, 70, 1)');
            }
            
            ctx.fillStyle = gradient;
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            // Generate raindrops when touching
            if (state.touchActive && (state.phase === 'touch' || state.phase === 'swipe' || state.phase === 'raining' || state.phase === 'cover' || state.phase === 'tilt')) {
                for (let i = 0; i < 3; i++) {
                    const angle = Math.random() * Math.PI * 2;
                    const speed = Math.random() * 2 + 1;
                    const vx = Math.cos(angle) * speed;
                    const vy = Math.sin(angle) * speed + 2;
                    state.raindrops.push(new Raindrop(state.touchX, state.touchY, vx, vy));
                }

                // Create ripples
                if (Math.random() < 0.3) {
                    state.raindrops.push(new Ripple(state.touchX, state.touchY));
                }

                // Occasionally reveal floating words
                if (Math.random() < 0.05) {
                    createFloatingWord(state.touchX, state.touchY);
                }
            }

            // Update and draw raindrops
            state.raindrops = state.raindrops.filter(drop => drop.isAlive());
            
            // Apply device tilt if available
            let tiltX = 0, tiltY = 0;
            if (state.phase === 'tilt' && deviceOrientation.gamma !== 0) {
                tiltX = deviceOrientation.gamma / 90;
                tiltY = deviceOrientation.beta / 90;
                state.hasTilted = true;

                if (Math.abs(tiltX) > 0.1 || Math.abs(tiltY) > 0.1) {
                    if (Date.now() - state.phaseStartTime > 3000) {
                        transitionPhase('cover');
                    }
                }
            }

            state.raindrops.forEach(drop => {
                if (drop instanceof Raindrop) {
                    drop.update(tiltX * 5, 1 + Math.abs(tiltY) * 0.5);
                    drop.draw(ctx);
                } else if (drop instanceof Ripple) {
                    drop.update();
                    drop.draw(ctx);
                }
            });

            // Check for reveal transition
            if (state.phase === 'cover' && state.raindrops.length < 10 && Date.now() - state.phaseStartTime > 5000) {
                transitionPhase('reveal');
            }

            requestAnimationFrame(animate);
        }

        // ============================================
        // INITIALIZATION
        // ============================================
        function init() {
            displayText('Some things don\'t start loudly.', 2000);
            setTimeout(() => {
                displayText('Touch the screen.', 2000, true);
            }, 2300);
            setTimeout(() => {
                transitionPhase('touch');
            }, 4500);
        }

        // Start animation loop and init
        animate();
        init();
    

✅ Low Risk - https://weekly-olive-44a9pt9kb3-ovhokk46dt.edgeone.app/

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

Security Scan Report: weekly-olive-44a9pt9kb3-ovhokk46dt.edgeone.app

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Bot Protection Detected

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