English

The domain name 'related-fuchsia-zrvdzowhuj-z1mj0c7jlu.edgeone.app' uses the application-focused generic top-level domain (.app); it also runs on subdomain 'related-fuchsia-zrvdzowhuj-z1mj0c7jlu'. The second-level label 'edgeone' is 7 characters long with four vowels and three consonants. Breaking it apart gives 2 words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/d0/b5/d0b5163c-02eb-4950-891b-fc75ab8348d2.html.gz

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

Gowri Shankar KalyanamandapamMap

176e894661aa9cdc9a5cba6c720044cbbf7b8bd80d1c9a142a7c24b1b6c50d15

3ed40678f4e0b3c2cc99c7982e2b80f339c055d09467ab4bfca225649eb48e3e

84bb58e7353cc6739f501456149b82f92f547064096f107b90ded5accc6aff63

viewport

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

Prudence Malinki

MarkMonitor Inc.

edgeone.app

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


        // Main page interactions for the invitation experience

        // Ensure the page always starts at the top envelope landing screen after refresh.
        if ('scrollRestoration' in history) {
            history.scrollRestoration = 'manual';
        }
        window.addEventListener('load', () => {
            window.scrollTo(0, 0);
        });

        // Spread static petals across the animation timeline so they fall continuously
        (function initPetalPhases() {
            const petals = document.querySelectorAll('.animate-float-petal');
            petals.forEach(p => {
                // choose a slow duration near the global 28s but add small variation
                const duration = 24 + Math.random() * 10; // 24s - 34s
                p.style.animationDuration = duration.toFixed(2) + 's';
                // negative delay places each petal somewhere along its path immediately
                p.style.animationDelay = (-Math.random() * duration).toFixed(2) + 's';
                // slightly vary opacity to add depth
                p.style.opacity = (0.7 + Math.random() * 0.3).toFixed(2);
            });
        })();

        // Initialize audio
        let audio;
        let isMuted = false;
        let musicBtn, musicIcon;

        function initScratchCard() {
            const canvas = document.getElementById('scratchCanvas');
            const reveal = document.getElementById('scratchCountdown');
            
            console.log('initScratchCard called');
            console.log('Canvas found:', !!canvas);
            console.log('Reveal element found:', !!reveal);
            
            if (!canvas || !reveal) {
                console.warn('Scratch card or countdown element not found');
                return;
            }

            // Wait for container to be properly sized
            const container = canvas.parentElement;
            if (!container) {
                console.warn('Canvas container not found');
                return;
            }

            // Get context and setup dimensions
            const ctx = canvas.getContext('2d', { willReadFrequently: true });
            
            // Force reflow to get proper dimensions
            const rect = container.getBoundingClientRect();
            const devicePixelRatio = window.devicePixelRatio || 1;
            canvas.width = Math.floor(rect.width * devicePixelRatio) || 400;
            canvas.height = Math.floor(rect.height * devicePixelRatio) || 160;
            canvas.style.width = rect.width + 'px';
            canvas.style.height = rect.height + 'px';
            ctx.setTransform(devicePixelRatio, 0, 0, devicePixelRatio, 0, 0);
            
            console.log('Canvas initialized:', canvas.width, 'x', canvas.height, 'CSS:', rect.width, 'x', rect.height);
            console.log('Reveal element classes:', reveal.className);
            
            // Fill entire canvas with opaque scratch surface - base color first
            ctx.fillStyle = '#c5b08a';
            ctx.fillRect(0, 0, rect.width, rect.height);
            
            // Add gradient overlay for visual appeal
            const gradient = ctx.createLinearGradient(0, 0, rect.width, rect.height);
            gradient.addColorStop(0, '#d7c1a2');
            gradient.addColorStop(1, '#c5b08a');
            ctx.fillStyle = gradient;
            ctx.fillRect(0, 0, rect.width, rect.height);
            
            // Add scratch texture
            ctx.fillStyle = 'rgba(0, 0, 0, 0.1)';
            for (let i = 0; i < rect.width; i += 3) {
                for (let j = 0; j < rect.height; j += 3) {
                    if ((i + j) % 6 === 0) ctx.fillRect(i, j, 1, 1);
                }
            }
            
            // Verify canvas has content
            const canvasData = ctx.getImageData(0, 0, 1, 1);
            console.log('Canvas pixel data:', canvasData.data);
            
            // Set up scratch effect - transparent where we erase
            ctx.globalCompositeOperation = 'destination-out';
            ctx.lineWidth = 40;
            ctx.lineCap = 'round';
            ctx.lineJoin = 'round';

            let drawing = false;
            let lastPoint = null;
            const radius = 30;
            const revealThreshold = 0.50;  // Reveal after ~50% of overlay is scratched
            let isRevealed = false;

            function getPointerPos(event) {
                const rect = canvas.getBoundingClientRect();
                return {
                    x: event.clientX - rect.left,
                    y: event.clientY - rect.top
                };
            }

            function checkReveal() {
                if (isRevealed) return;

                const imageData = ctx.getImageData(0, 0, rect.width, rect.height).data;
                let cleared = 0;
                let sampled = 0;
                for (let i = 3; i < imageData.length; i += 20) {
                    sampled++;
                    if (imageData[i] === 0) cleared++;
                }
                const percent = sampled > 0 ? cleared / sampled : 0;
                if (percent >= revealThreshold) {
                    isRevealed = true;
                    console.log('Threshold reached! Percent:', percent.toFixed(3), 'Threshold:', revealThreshold);
                    reveal.classList.remove('hidden');
                    canvas.classList.add('scratch-fade');
                    setTimeout(() => {
                        canvas.classList.add('scratch-hidden');
                    }, 950);
                    setTimeout(() => {
                        reveal.classList.add('revealed');
                        // hide the helper hint below the scratch card
                        const hint = document.getElementById('scratchHint');
                        if (hint) hint.classList.add('hint-hidden');

                        const countdownValues = [
                            document.getElementById('days'),
                            document.getElementById('hours'),
                            document.getElementById('minutes'),
                            document.getElementById('seconds')
                        ];
                        countdownValues.forEach((el, index) => {
                            if (!el) return;
                            el.classList.remove('countdown-number-appear');
                            setTimeout(() => el.classList.add('countdown-number-appear'), index * 90);
                        });
                        burstConfetti();
                        console.log('Confetti triggered');
                    }, 10);
                    reveal.removeAttribute('aria-hidden');
                }
            }

            function drawLine(from, to) {
                ctx.beginPath();
                ctx.moveTo(from.x, from.y);
                ctx.lineTo(to.x, to.y);
                ctx.stroke();
            }

            function startDrawing(event) {
                drawing = true;
                lastPoint = getPointerPos(event);
                drawLine(lastPoint, lastPoint);
                checkReveal();
            }

            function stopDrawing() {
                drawing = false;
                lastPoint = null;
            }

            function onPointerMove(event) {
                if (!drawing) return;
                const point = getPointerPos(event);
                drawLine(lastPoint, point);
                lastPoint = point;
                checkReveal();
            }

            canvas.addEventListener('pointerdown', event => {
                event.preventDefault();
                startDrawing(event);
            });
            window.addEventListener('pointermove', onPointerMove);
            window.addEventListener('pointerup', event => {
                if (!drawing) return;
                stopDrawing();
            });
            canvas.addEventListener('pointerleave', stopDrawing);

            console.log('Scratch card initialized successfully');
        }

        function burstConfetti() {
            const symbols = ['💕', '🌸', '✨', '🎊', '🌿', '🌼'];
            const canvas = document.getElementById('scratchCanvas');

            // Compute a safe rect for confetti origin; prefer the canvas if available
            let rect = { left: window.innerWidth / 2, top: window.innerHeight / 3, width: 0, height: 0 };
            if (canvas) {
                try {
                    rect = canvas.getBoundingClientRect();
                } catch (e) {
                    // ignore and use fallback
                }

                // ensure the canvas fades and is hidden while confetti runs
                canvas.classList.add('scratch-fade');
                setTimeout(() => canvas.classList.add('scratch-hidden'), 950);
            }

            for (let i = 0; i < 20; i++) {
                const confetti = document.createElement('div');
                confetti.className = 'petal-fall';
                confetti.textContent = symbols[Math.floor(Math.random() * symbols.length)];
                const angle = (Math.PI * 2 * i) / 20;
                const distance = 30 + Math.random() * 60;
                const cx = (rect.left || 0) + (rect.width || 0) / 2;
                const cy = (rect.top || 0) + (rect.height || 0) / 2;
                confetti.style.left = (cx + Math.cos(angle) * distance) + 'px';
                confetti.style.top = (cy + Math.sin(angle) * distance) + 'px';
                confetti.style.fontSize = (18 + Math.random() * 30) + 'px';
                confetti.style.animationDuration = (1200 + Math.random() * 2200) + 'ms';
                confetti.style.zIndex = 100;
                document.body.appendChild(confetti);
                setTimeout(() => confetti.remove(), 4200);
            }
        }

        // Initialize scratch card with proper timing
        function readyInitScratchCard() {
            // Give the DOM time to fully render
            setTimeout(() => {
                const canvas = document.getElementById('scratchCanvas');
                if (!canvas) {
                    console.error('Canvas not found');
                    return;
                }
                
                // Re-check container has proper dimensions
                const container = canvas.parentElement;
                if (container.offsetWidth === 0 || container.offsetHeight === 0) {
                    console.warn('Container has no dimensions, retrying...');
                    setTimeout(readyInitScratchCard, 100);
                    return;
                }
                
                initScratchCard();
            }, 50);
        }

        window.addEventListener('load', readyInitScratchCard);
        document.addEventListener('DOMContentLoaded', readyInitScratchCard);
        
        // Also initialize immediately if DOM is already ready
        if (document.readyState === 'complete' || document.readyState === 'interactive') {
            readyInitScratchCard();
        }
        
        try {
            audio = new Audio('solo_sita_kalyanam.mp3');
            audio.loop = true;
            audio.volume = 0.5;
        } catch(e) { 
            audio = null; 
        }

        // Get music button elements
        musicBtn = document.getElementById('musicBtn');
        musicIcon = document.getElementById('musicIcon');

        // Envelope functionality: opens the invitation and reveals the main content.
        const envelope = document.getElementById('envelope');
        const envelopeContainer = document.getElementById('envelopeContainer');
        const mainContent = document.getElementById('mainContent');

        envelope.addEventListener('click', () => {
            envelope.classList.add('open');
            setTimeout(() => {
                envelopeContainer.classList.add('fade-out');
                setTimeout(() => {
                    envelopeContainer.style.display = 'none';
                    window.scrollTo({ top: 0, behavior: 'auto' });
                }, 900);
                mainContent.style.display = 'block';
                mainContent.classList.add('show');
                
                // Auto-play audio when envelope opens
                if (audio) {
                    audio.play().catch(err => console.log('Audio play failed:', err));
                    isMuted = false;
                    musicIcon.textContent = '🔊';
                }
                
                // Scroll to the main hero section
                const heroHeading = document.querySelector('h1.script-font');
                if (heroHeading) {
                    setTimeout(() => {
                        // Smooth scroll down by 250px with controlled speed
                        window.scrollBy({
                            top: 700,
                            behavior: 'smooth'
                        });
                    }, 400);
                }
                // Reveal butterfly after envelope opens
                const butterfly = document.querySelector('.butterfly-path');
                if (butterfly) {
                    butterfly.style.display = 'block';
                    // restart animation so it begins from the start position
                    butterfly.style.animation = 'none';
                    // force reflow
                    void butterfly.offsetWidth;
                    butterfly.style.animation = '';
                }
            }, 300);
        });

        // Spawn falling emoji clones from the decorative floral spans (recreates old petal behavior)
        (function() {
            // Do NOT include `.animate-float-petal` here — those are static petals handled by CSS.
            const anchors = document.querySelectorAll('.animate-float, .animate-float-slow, .animate-float-reverse');
            const symbols = ['🌸','🌼','🌿','🍃','🌻'];

            function spawnFallingFrom(anchor, opts = {}) {
                const rect = anchor.getBoundingClientRect();
                const clone = document.createElement('div');
                clone.className = 'petal-fall';
                clone.textContent = opts.symbol || anchor.textContent.trim() || symbols[Math.floor(Math.random()*symbols.length)];
                // position clone at anchor's current screen position (or randomized x)
                const left = (typeof opts.left === 'number') ? opts.left : rect.left;
                const top = (typeof opts.top === 'number') ? opts.top : rect.top;
                clone.style.left = left + 'px';
                clone.style.top = top + 'px';
                // adopt font-size of anchor if set, otherwise random small sizes
                const fs = window.getComputedStyle(anchor).fontSize;
                clone.style.fontSize = (fs || (14 + Math.random()*18) + 'px');
                // longer durations for slow-motion rain
                const duration = 8000 + Math.random() * 14000; // 8s - 22s
                clone.style.animationDuration = duration + 'ms';
                document.body.appendChild(clone);
                setTimeout(() => clone.remove(), duration + 200);
            }

            // Less frequent spawning to reduce on-screen density
            setInterval(() => {
                // spawn from anchors with lower probability
                anchors.forEach(anchor => {
                    if (Math.random() < 0.35) spawnFallingFrom(anchor);
                });

                // occasional random rain spawn near top across the viewport
                if (Math.random() < 0.25) {
                    const x = Math.random() * window.innerWidth;
                    const y = -40 + (Math.random() * 40); // slightly above viewport
                    spawnFallingFrom(document.body, { left: x, top: y, symbol: symbols[Math.floor(Math.random()*symbols.length)] });
                }
            }, 700);
        })();

        // Countdown timer: calculates remaining time until the wedding date.
        function updateCountdown() {
            const weddingDate = new Date('2026-07-19T12:48:00').getTime();
            const now = new Date().getTime();
            const diff = weddingDate - now;

            const days = Math.floor(diff / (1000 * 60 * 60 * 24));
            const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
            const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
            const seconds = Math.floor((diff % (1000 * 60)) / 1000);

            document.getElementById('days').textContent = String(days).padStart(2, '0');
            document.getElementById('hours').textContent = String(hours).padStart(2, '0');
            document.getElementById('minutes').textContent = String(minutes).padStart(2, '0');
            document.getElementById('seconds').textContent = String(seconds).padStart(2, '0');
        }

        updateCountdown();
        setInterval(updateCountdown, 1000);

        // Music button handling: toggles audio playback and icon state on click.
        musicBtn.addEventListener('click', () => {
            if (!audio) return;
            
            isMuted = !isMuted;
            if (isMuted) {
                audio.pause();
                musicIcon.textContent = '🔇';
            } else {
                audio.play().catch(err => console.log('Audio play failed:', err));
                musicIcon.textContent = '🔊';
            }
        });

        // Smooth scrolling: applies to internal anchor links on the page.
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                const target = document.querySelector(this.getAttribute('href'));
                if (target) {
                    target.scrollIntoView({ behavior: 'smooth' });
                }
            });
        });
    

Tailwind CSS

Abhilash &amp; Abhilash1 - Wedding Invitation

✅ Low Risk - https://related-fuchsia-zrvdzowhuj-z1mj0c7jlu.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
5	43.152.26.58	Singapore	AS139341ACE
3	142.250.154.94	United States	AS15169Google LLC
3	151.101.65.181	United States	AS54113Fastly, Inc.
3	104.26.2.143	United States	AS13335Cloudflare, Inc.
3	74.125.29.95	United States	AS15169Google LLC
17	5	-	-

Security Scan Report: related-fuchsia-zrvdzowhuj-z1mj0c7jlu.edgeone.app

Summary

AI Security Verdict

Moderate 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