English

Domain 'endless-blue-vwz15r6skj-l93dojqqkb.edgeone.app' uses the application-focused generic top-level domain (.app); it also runs on subdomain 'endless-blue-vwz15r6skj-l93dojqqkb'. Its registrable label 'edgeone' stretches across 7 characters split between four vowels and three consonants. Word splitting yields two words: edge, one. Expect 3.5 characters per word on average. No strong language cues emerged from the frequency lists.

html/da/3d/da3d674b-8471-4782-8d44-3c3e95e02fc7.html.gz

a68b21c9553d614384f7f459622e46e02e3c9cfdf7392915a2fa1d615e338473

3d0522374f2b299b26783d49325bfda9bc6456804de48e9392debf3c5450018d

f7caec36c5653db4a6dc12b357c7a863805c6c0159bf7c6853770ac850db2b26

ee14cd241f693504a9ea55fa2f2ed3b24da1f7cf804926716069d0d232434d8e

7ca4bd4f830b0bdf79cc6f94ebf93cb17e74802ef93ae9b6394da373e453542b

c712421860c8a287769e248ea669da9bb16be11f61d1b8403f288caa1ac7e3d7

viewport

html/da/3d/da3d674b-8471-4782-8d44-3c3e95e02fc7_nodriver.html.gz

Gesture &amp; Custom Text Particles

Prudence Malinki

MarkMonitor Inc.

edgeone.app

Abuse Account

Fastly RIR Administrator

Fastly Network Operations

Fastly, Inc.

SKYCA-3


        import * as THREE from 'https://cdn.skypack.dev/three@0.136.0';

        // --- Configuration ---
        const config = {
            particleColor: 0x8A2BE2,
            particleSize: 1.2,
            sphereRadius: 80,
            morphSpeed: 0.05
        };

        let scene, camera, renderer, particles;
        let targetPositionsSphere, targetPositionsText;
        
        // Hand Gesture State
        let isMorphingToText = false; 

        // UI Elements
        const textInput = document.getElementById('userText');
        const updateBtn = document.getElementById('updateBtn');

        initThreeJS();
        initMediaPipe();
        setupUI();

        // ---------------------------------------------------------
        // 1. UI LOGIC
        // ---------------------------------------------------------
        function setupUI() {
            updateBtn.addEventListener('click', () => {
                regenerateParticles(textInput.value);
            });

            textInput.addEventListener('keyup', (event) => {
                if (event.key === 'Enter') {
                    regenerateParticles(textInput.value);
                }
            });
        }

        // ---------------------------------------------------------
        // 2. THREE.JS CORE
        // ---------------------------------------------------------
        function initThreeJS() {
            scene = new THREE.Scene();
            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
            camera.position.z = 200;

            renderer = new THREE.WebGLRenderer({ antialias: true });
            renderer.setSize(window.innerWidth, window.innerHeight);
            renderer.setPixelRatio(window.devicePixelRatio);
            document.body.appendChild(renderer.domElement);

            // Initial Generation
            regenerateParticles(textInput.value);

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

            animate();
        }

        // Function to destroy old particles and create new ones based on text
        function regenerateParticles(newText) {
            // Clean up old system if it exists
            if (particles) {
                scene.remove(particles);
                particles.geometry.dispose();
                particles.material.dispose();
            }

            // 1. Generate Text Coordinates
            targetPositionsText = getTextCoordinates(newText);
            
            // 2. Calculate Sphere Coordinates based on particle count
            const particleCount = targetPositionsText.length / 3;
            targetPositionsSphere = getSphereCoordinates(particleCount, config.sphereRadius);

            // 3. Create new Geometry
            // We start them at the sphere position for a cool effect
            const currentPositions = new Float32Array(targetPositionsSphere);
            const geometry = new THREE.BufferGeometry();
            geometry.setAttribute('position', new THREE.BufferAttribute(currentPositions, 3));

            const material = new THREE.PointsMaterial({
                color: config.particleColor,
                size: config.particleSize,
                blending: THREE.AdditiveBlending,
                transparent: true,
                opacity: 0.8,
                depthWrite: false
            });

            particles = new THREE.Points(geometry, material);
            scene.add(particles);
        }

        function getTextCoordinates(text) {
            const canvas = document.createElement('canvas');
            const ctx = canvas.getContext('2d');
            const fontSize = 60;
            
            // Make canvas wide enough for long text
            canvas.width = window.innerWidth * 2; 
            canvas.height = window.innerHeight;

            ctx.font = `bold ${fontSize}px Arial`;
            ctx.fillStyle = 'white';
            ctx.textAlign = 'center';
            ctx.textBaseline = 'middle';
            ctx.fillText(text, canvas.width / 2, canvas.height / 2);

            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
            const positions = [];
            const step = 3; 

            for (let y = 0; y < canvas.height; y += step) {
                for (let x = 0; x < canvas.width; x += step) {
                    if (imageData[(y * canvas.width + x) * 4] > 0) {
                        positions.push(
                            (x - canvas.width / 2) * 1.5, 
                            -(y - canvas.height / 2) * 1.5, 
                            0
                        );
                    }
                }
            }
            return new Float32Array(positions);
        }

        function getSphereCoordinates(count, radius) {
            const positions = [];
            for (let i = 0; i < count; i++) {
                const phi = Math.acos(-1 + (2 * i) / count);
                const theta = Math.sqrt(count * Math.PI) * phi;
                positions.push(
                    radius * Math.cos(theta) * Math.sin(phi),
                    radius * Math.sin(theta) * Math.sin(phi),
                    radius * Math.cos(phi)
                );
            }
            return new Float32Array(positions);
        }

        function animate() {
            requestAnimationFrame(animate);

            if (particles) {
                const positions = particles.geometry.attributes.position.array;
                const target = isMorphingToText ? targetPositionsText : targetPositionsSphere;

                // Move particles
                for (let i = 0; i < positions.length; i++) {
                    positions[i] += (target[i] - positions[i]) * config.morphSpeed;
                }

                particles.rotation.y += 0.002;
                particles.geometry.attributes.position.needsUpdate = true;
            }

            renderer.render(scene, camera);
        }

        // ---------------------------------------------------------
        // 3. MEDIAPIPE HAND TRACKING
        // ---------------------------------------------------------
        function initMediaPipe() {
            const videoElement = document.getElementById('input_video');
            const statusElement = document.getElementById('status');

            const hands = new Hands({locateFile: (file) => {
                return `https://cdn.jsdelivr.net/npm/@mediapipe/hands/${file}`;
            }});

            hands.setOptions({
                maxNumHands: 1,
                modelComplexity: 1,
                minDetectionConfidence: 0.5,
                minTrackingConfidence: 0.5
            });

            hands.onResults((results) => {
                document.getElementById('loading').style.display = 'none';

                if (results.multiHandLandmarks && results.multiHandLandmarks.length > 0) {
                    const landmarks = results.multiHandLandmarks[0];
                    const thumbTip = landmarks[4];
                    const indexTip = landmarks[8];
                    
                    const distance = Math.sqrt(
                        Math.pow(thumbTip.x - indexTip.x, 2) + 
                        Math.pow(thumbTip.y - indexTip.y, 2)
                    );

                    if (distance < 0.05) {
                        isMorphingToText = false; // Pinch = Sphere
                        statusElement.innerText = "Sphere (Pinch)";
                    } else {
                        isMorphingToText = true;  // Open = Text
                        statusElement.innerText = "Text (Open)";
                    }
                } else {
                    statusElement.innerText = "No Hand Detected";
                }
            });

            const camera = new Camera(videoElement, {
                onFrame: async () => {
                    await hands.send({image: videoElement});
                },
                width: 640,
                height: 480
            });
            
            camera.start();
        }
    

jsDelivr

✅ Low Risk - https://endless-blue-vwz15r6skj-l93dojqqkb.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
3	104.26.13.82	United States	AS54113
2	151.101.129.229	United States	AS54113FASTLY
2	43.152.26.58	Singapore	AS139341ACE
7	3	-	-

Security Scan Report: endless-blue-vwz15r6skj-l93dojqqkb.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

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