entertainment media

documentation technical

technology software

healthcare medical

English

Within the application-focused generic top-level domain (.app), 'sorrymam1-g6erk87lud.edgeone.app' is registered; it also runs on subdomain 'sorrymam1-g6erk87lud'. Count 7 characters in 'edgeone' split between four vowels and three consonants. It segments into 2 words: edge, one. Average segment length settles at 3.5 characters. No strong language cues emerged from the frequency lists.

html/1e/f9/1ef9b313-1ea4-4f0f-9304-2066e815391d.html.gz

sha256=:r1J8N0tWuGiHN6Qtf86ny4qutXpOPG2pi03/1VvMNRQ=:

af527c374b56b8688737a42d7fcea7cb8aaeb57a4e3c6da98b4dffd55bcc3514

d3aa3a093984522e544b1631420e8b4cfaeff8a6b9b2c23133ed2949dd3fed0a

7406b93d481b209e802865e16c67ff0f72964eb3f916f22acee660b14861b545

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

viewport

html/1e/f9/1ef9b313-1ea4-4f0f-9304-2066e815391d_nodriver.html.gz

Sorry Mam - 3D Particles (Mobile + Gyro)

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


        import * as THREE from 'three';

        // --- Setup scene, camera, renderer (optimized for mobile) ---
        const scene = new THREE.Scene();
        scene.background = new THREE.Color(0x0a0a1a);

        const camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 0.1, 1000);
        camera.position.set(0, 0.5, 22); // slight upward tilt to frame better
        camera.lookAt(0, 0, 0);

        const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: false, powerPreference: "default" });
        renderer.setSize(window.innerWidth, window.innerHeight);
        renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5)); // limit for performance
        document.body.appendChild(renderer.domElement);

        // --- Sharper particle texture (mobile friendly) ---
        function createParticleTexture() {
            const canvas = document.createElement('canvas');
            canvas.width = 64;
            canvas.height = 64;
            const ctx = canvas.getContext('2d');
            const gradient = ctx.createRadialGradient(32, 32, 0, 32, 32, 32);
            gradient.addColorStop(0, 'rgba(255, 255, 255, 1)');
            gradient.addColorStop(0.3, 'rgba(255, 200, 230, 1)');
            gradient.addColorStop(0.5, 'rgba(200, 150, 255, 0.9)');
            gradient.addColorStop(0.7, 'rgba(120, 100, 255, 0.5)');
            gradient.addColorStop(1, 'rgba(255, 255, 255, 0)');
            ctx.fillStyle = gradient;
            ctx.fillRect(0, 0, 64, 64);
            return new THREE.CanvasTexture(canvas);
        }

        const particleTexture = createParticleTexture();

        // --- Generate text particles (balanced for mobile: stride 4) ---
        function generateTextParticles() {
            const canvas = document.createElement('canvas');
            canvas.width = 1024;
            canvas.height = 512;
            const ctx = canvas.getContext('2d');
            ctx.fillStyle = '#000000';
            ctx.fillRect(0, 0, canvas.width, canvas.height);
            ctx.fillStyle = '#ffffff';
            ctx.font = 'bold 170px "Arial", "Helvetica", sans-serif';
            ctx.textAlign = 'center';
            ctx.textBaseline = 'middle';
            ctx.fillText('Sorry Mam', canvas.width / 2, canvas.height / 2 - 25);
            ctx.font = '150px "Arial", "Helvetica", sans-serif';
            ctx.fillText('❤️', canvas.width / 2, canvas.height / 2 + 110);

            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
            const data = imageData.data;
            const positions = [];
            const colors = [];
            const stride = 4; // Slightly less dense for mobile performance
            const threshold = 200;
            const scaleX = 16.0 / canvas.width;
            const scaleY = 8.0 / canvas.height;
            const offsetX = -8.0;
            const offsetY = 4.0;

            for (let y = 0; y < canvas.height; y += stride) {
                for (let x = 0; x < canvas.width; x += stride) {
                    const index = (y * canvas.width + x) * 4;
                    if (data[index] > threshold) {
                        const jitter = 0.1;
                        const posX = x * scaleX + offsetX + (Math.random() - 0.5) * jitter;
                        const posY = -(y * scaleY) + offsetY + (Math.random() - 0.5) * jitter;
                        const posZ = (Math.random() - 0.5) * 3.0;
                        positions.push(posX, posY, posZ);
                        const hue = ((posX + 8) / 16) * 0.6 + 0.7;
                        const color = new THREE.Color().setHSL(hue % 1.0, 0.9, 0.6 + 0.2 * Math.sin(posY * 1.5));
                        colors.push(color.r, color.g, color.b);
                    }
                }
            }
            console.log(`Mobile particles: ${positions.length / 3}`);
            const geometry = new THREE.BufferGeometry();
            geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
            geometry.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
            return geometry;
        }

        const textGeometry = generateTextParticles();
        const textMaterial = new THREE.PointsMaterial({
            size: 0.16,
            map: particleTexture,
            vertexColors: true,
            transparent: true,
            blending: THREE.AdditiveBlending,
            depthWrite: false,
            sizeAttenuation: true,
            opacity: 0.95
        });
        const textParticles = new THREE.Points(textGeometry, textMaterial);
        
        // Group for rotation control
        const particleGroup = new THREE.Group();
        particleGroup.add(textParticles);
        scene.add(particleGroup);

        // --- Background stars (reduced count for mobile) ---
        const starGeo = new THREE.BufferGeometry();
        const starCount = 1200;
        const starPos = new Float32Array(starCount * 3);
        const starCol = new Float32Array(starCount * 3);
        for (let i = 0; i < starCount; i++) {
            const r = 40 + Math.random() * 80;
            const theta = Math.random() * Math.PI * 2;
            const phi = Math.acos(2 * Math.random() - 1);
            starPos[i*3] = r * Math.sin(phi) * Math.cos(theta);
            starPos[i*3+1] = r * Math.sin(phi) * Math.sin(theta);
            starPos[i*3+2] = r * Math.cos(phi);
            starCol[i*3] = 0.7 + 0.5 * Math.random();
            starCol[i*3+1] = 0.6 + 0.5 * Math.random();
            starCol[i*3+2] = 0.9 + 0.3 * Math.random();
        }
        starGeo.setAttribute('position', new THREE.BufferAttribute(starPos, 3));
        starGeo.setAttribute('color', new THREE.BufferAttribute(starCol, 3));
        const starMat = new THREE.PointsMaterial({ size: 0.3, map: particleTexture, vertexColors: true, blending: THREE.AdditiveBlending, transparent: true, depthWrite: false, sizeAttenuation: true });
        const stars = new THREE.Points(starGeo, starMat);
        scene.add(stars);

        // --- Decorative aura (simplified for mobile) ---
        const auraGeo = new THREE.BufferGeometry();
        const auraCount = 400;
        const auraPos = [];
        const auraCol = [];
        for (let i = 0; i < auraCount; i++) {
            const angle = (i / auraCount) * Math.PI * 2;
            const radius = 10 + Math.sin(angle * 6) * 1.5;
            const x = Math.cos(angle) * radius;
            const y = Math.sin(angle) * radius * 0.4;
            const z = Math.cos(angle * 3) * 3;
            auraPos.push(x, y, z);
            const col = new THREE.Color().setHSL(angle / (Math.PI*2), 0.9, 0.6);
            auraCol.push(col.r, col.g, col.b);
        }
        auraGeo.setAttribute('position', new THREE.Float32BufferAttribute(auraPos, 3));
        auraGeo.setAttribute('color', new THREE.Float32BufferAttribute(auraCol, 3));
        const auraMat = new THREE.PointsMaterial({ size: 0.15, map: particleTexture, vertexColors: true, blending: THREE.AdditiveBlending, transparent: true, depthWrite: false, sizeAttenuation: true });
        const aura = new THREE.Points(auraGeo, auraMat);
        particleGroup.add(aura);

        // --- Lights ---
        const ambientLight = new THREE.AmbientLight(0x404060);
        scene.add(ambientLight);
        const pointLight = new THREE.PointLight(0xffaaff, 0.6, 30);
        pointLight.position.set(3, 3, 8);
        scene.add(pointLight);

        // --- Interaction variables ---
        // Mouse/touch
        let mouseX = 0, mouseY = 0;
        let targetRotY = 0, targetRotX = 0;
        // Gyro
        let gyroRotY = 0, gyroRotX = 0;
        let useGyro = false; // becomes true after permission granted and first data received
        let gyroAvailable = false;

        // Smoothing
        const smoothFactor = 0.08;

        // --- Event listeners for touch/mouse ---
        window.addEventListener('mousemove', (e) => {
            if (!useGyro) { // only use mouse when gyro not active
                mouseX = (e.clientX / window.innerWidth) * 2 - 1;
                mouseY = -(e.clientY / window.innerHeight) * 2 + 1;
                targetRotY = mouseX * 0.8;
                targetRotX = mouseY * 0.5;
            }
        });
        window.addEventListener('touchmove', (e) => {
            if (!useGyro && e.touches.length) {
                mouseX = (e.touches[0].clientX / window.innerWidth) * 2 - 1;
                mouseY = -(e.touches[0].clientY / window.innerHeight) * 2 + 1;
                targetRotY = mouseX * 0.8;
                targetRotX = mouseY * 0.5;
            }
        }, { passive: true });

        // --- Gyroscope handling ---
        const gyroBtn = document.getElementById('gyro-btn');
        
        function handleGyro(event) {
            if (!useGyro) return;
            // beta: front-back tilt (-180 to 180), gamma: left-right (-90 to 90)
            let beta = event.beta;  // -180 to 180 (tilt front/back)
            let gamma = event.gamma; // -90 to 90 (tilt left/right)
            
            if (beta !== null && gamma !== null) {
                // Normalize to reasonable ranges: beta from -45 to 45 deg => X rotation, gamma -45 to 45 => Y rotation
                // Map to radian range ~ -0.6 to 0.6
                let rotX = Math.max(-0.6, Math.min(0.6, (beta / 90) * 0.8));
                let rotY = Math.max(-0.8, Math.min(0.8, (gamma / 60) * 0.8));
                
                gyroRotX = rotX;
                gyroRotY = rotY;
            }
        }

        // Permission for iOS
        function requestGyroPermission() {
            if (typeof DeviceOrientationEvent !== 'undefined' && typeof DeviceOrientationEvent.requestPermission === 'function') {
                // iOS 13+
                DeviceOrientationEvent.requestPermission()
                    .then(permissionState => {
                        if (permissionState === 'granted') {
                            window.addEventListener('deviceorientation', handleGyro);
                            useGyro = true;
                            gyroBtn.style.background = 'rgba(70, 130, 200, 0.8)';
                            gyroBtn.textContent = '🌀 Gyro ON';
                        } else {
                            alert('Gyro permission denied. Use touch to rotate.');
                        }
                    })
                    .catch(console.error);
            } else {
                // Non-iOS or older iOS
                if (window.DeviceOrientationEvent) {
                    window.addEventListener('deviceorientation', handleGyro);
                    useGyro = true;
                    gyroBtn.style.background = 'rgba(70, 130, 200, 0.8)';
                    gyroBtn.textContent = '🌀 Gyro ON';
                } else {
                    alert('Gyroscope not supported on this device.');
                }
            }
        }

        gyroBtn.addEventListener('click', requestGyroPermission);

        // Fallback: if no gyro, still show button but disable after click?
        // Also on Android, it may work without permission but we need to ensure we don't double-add listener.
        // We'll just use the same handler.

        // --- Animation loop ---
        let clock = new THREE.Clock();

        function animate() {
            requestAnimationFrame(animate);
            const delta = clock.getDelta();
            const elapsed = performance.now() / 1000;

            // Choose target rotation based on mode
            let targetX, targetY;
            if (useGyro) {
                targetX = gyroRotX;
                targetY = gyroRotY;
            } else {
                targetX = targetRotX;
                targetY = targetRotY;
            }

            // Smoothly interpolate group rotation
            particleGroup.rotation.x += (targetX - particleGroup.rotation.x) * smoothFactor;
            particleGroup.rotation.y += (targetY - particleGroup.rotation.y) * smoothFactor;

            // Subtle auto drift when idle
            if (!useGyro && Math.abs(mouseX) < 0.1 && Math.abs(mouseY) < 0.1) {
                particleGroup.rotation.y += 0.0005 * Math.sin(elapsed * 0.2);
                particleGroup.rotation.x += 0.0003 * Math.cos(elapsed * 0.3);
            }

            // Background star rotation
            stars.rotation.y += 0.0001;
            stars.rotation.x += 0.00005;

            // Pulse particle size slightly
            const pulse = Math.sin(elapsed * 3) * 0.015 + 0.15;
            textMaterial.size = pulse;
            auraMat.size = pulse * 1.1;

            // Subtle camera movement (very slight)
            camera.position.x += (Math.sin(elapsed * 0.2) * 0.8 - camera.position.x) * 0.005;
            camera.position.y += (Math.cos(elapsed * 0.3) * 0.6 - camera.position.y) * 0.005;
            camera.lookAt(0, 0, 0);

            renderer.render(scene, camera);
        }

        animate();

        // --- Resize handler ---
        window.addEventListener('resize', () => {
            camera.aspect = window.innerWidth / window.innerHeight;
            camera.updateProjectionMatrix();
            renderer.setSize(window.innerWidth, window.innerHeight);
        });

        // --- Prevent scroll on touch (to avoid page move) ---
        document.body.addEventListener('touchstart', (e) => { e.preventDefault(); }, { passive: false });
    

✅ Low Risk - https://sorrymam1-g6erk87lud.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
2	43.152.26.58	Singapore	AS139341ACE
1	104.18.0.22	United States	AS13335Cloudflare, Inc.
3	2	-	-

Security Scan Report: sorrymam1-g6erk87lud.edgeone.app

Summary

AI Security Verdict

Low Risk

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