Chinese

Within the developer-focused generic top-level domain (.dev), 'important-scarlet-dnvoyqku-dpnwsc9fcine.edgeone.dev' is registered, featuring subdomain 'important-scarlet-dnvoyqku-dpnwsc9fcine'. The registrable portion 'edgeone' spans 7 characters holding four vowels versus three consonants. Word splitting yields two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

b28b9a4a40ca9fbbef72967aac10326dab53cba4d0f731e4909f5807af9df7a9

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

Prudence Malinki

MarkMonitor Inc.

edgeone.dev

IRT-SG-ACE

ACE administrator

ACE-SG


        // 配置参数
        const config = {
            gas: { count: 30, radius: 5, spacing: 0 },
            liquid: { count: 50, radius: 7, spacing: 1.2 },
            solid: { count: 64, radius: 9.6, spacing: 1.5 }
        };

        // 初始化画布
        const canvases = {
            gas: initCanvas('gasCanvas', 300, 200),
            liquid: initCanvas('liquidCanvas', 300, 200),
            solid: initCanvas('solidCanvas', 300, 200)
        };

        // 分子类
        class Molecule {
            constructor(type, canvas) {
                this.type = type;
                this.canvas = canvas;
                this.radius = config[type].radius;
                this.mass = this.radius * 2;
                this.originalX = 0;
                this.originalY = 0;
                this.phase = Math.random() * Math.PI * 2;
                this.resetPosition();
                
                this.vx = this.getInitialSpeed(type);
                this.vy = this.getInitialSpeed(type);
            }

            getInitialSpeed(type) {
                const base = (Math.random() - 0.5);
                return {
                    gas: base * 2,
                    liquid: base * 0.8,
                    solid: base * 0.3
                }[type];
            }

            resetPosition() {
                if (this.type === 'solid') {
                    const col = this.canvas.index % 8;
                    const row = Math.floor(this.canvas.index / 8);
                    this.originalX = col * (this.canvas.width/8) + this.radius*2;
                    this.originalY = row * (this.canvas.height/8) + this.radius*2;
                    this.x = this.originalX;
                    this.y = this.originalY;
                } else {
                    this.x = this.radius + Math.random() * (this.canvas.width - this.radius*2);
                    this.y = this.radius + Math.random() * (this.canvas.height - this.radius*2);
                }
            }

            update(speedFactor) {
                switch(this.type) {
                    case 'gas': this.gasUpdate(speedFactor); break;
                    case 'liquid': this.liquidUpdate(speedFactor); break;
                    case 'solid': this.solidUpdate(speedFactor); break;
                }
            }

            gasUpdate(speedFactor) {
                this.vx *= 0.999;
                this.vy *= 0.999;
                this.x += this.vx * speedFactor;
                this.y += this.vy * speedFactor;
                this.handleBoundary(0.95);
            }

            liquidUpdate(speedFactor) {
                this.x += this.vx * speedFactor * 0.6;
                this.y += this.vy * speedFactor * 0.6;
                this.handleBoundary(0.98);
            }

            solidUpdate(speedFactor) {
                const amplitude = speedFactor * 0.3;
                this.vx = Math.sin(Date.now()/100 + this.phase) * amplitude;
                this.vy = Math.cos(Date.now()/100 + this.phase) * amplitude;
                this.x = this.originalX + this.vx;
                this.y = this.originalY + this.vy;
            }

            handleBoundary(bounce) {
                if(this.x <= this.radius) {
                    this.vx = Math.abs(this.vx) * bounce;
                    this.x = this.radius;
                }
                if(this.x >= this.canvas.width - this.radius) {
                    this.vx = -Math.abs(this.vx) * bounce;
                    this.x = this.canvas.width - this.radius;
                }
                if(this.y <= this.radius) {
                    this.vy = Math.abs(this.vy) * bounce;
                    this.y = this.radius;
                }
                if(this.y >= this.canvas.height - this.radius) {
                    this.vy = -Math.abs(this.vy) * bounce;
                    this.y = this.canvas.height - this.radius;
                }
            }

            checkCollision(other) {
                const dx = other.x - this.x;
                const dy = other.y - this.y;
                const distance = Math.sqrt(dx*dx + dy*dy);
                const minDistance = this.radius + other.radius;

                if (distance < minDistance) {
                    const nx = dx / distance;
                    const ny = dy / distance;
                    const tx = -ny;
                    const ty = nx;

                    const v1n = this.vx * nx + this.vy * ny;
                    const v1t = this.vx * tx + this.vy * ty;
                    const v2n = other.vx * nx + other.vy * ny;
                    const v2t = other.vx * tx + other.vy * ty;

                    const elasticity = 0.9;
                    const newV1n = (v1n * (this.mass - other.mass) + 2 * other.mass * v2n) / (this.mass + other.mass);
                    const newV2n = (v2n * (other.mass - this.mass) + 2 * this.mass * v1n) / (this.mass + other.mass);

                    this.vx = (tx * v1t) + (nx * newV1n);
                    this.vy = (ty * v1t) + (ny * newV1n);
                    other.vx = (tx * v2t) + (nx * newV2n);
                    other.vy = (ty * v2t) + (ny * newV2n);

                    const overlap = (minDistance - distance) * 0.5;
                    this.x -= nx * overlap;
                    this.y -= ny * overlap;
                    other.x += nx * overlap;
                    other.y += ny * overlap;
                }
            }

            draw() {
                const ctx = this.canvas.ctx;
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.radius, 0, Math.PI*2);
                ctx.fillStyle = {
                    gas: '#FF5555',
                    liquid: '#55AAFF',
                    solid: '#55FF55'
                }[this.type];
                ctx.fill();
            }
        }

        // 系统管理
        let systems = createSystems();

        function createSystems() {
            return {
                gas: createSystem('gas', canvases.gas),
                liquid: createSystem('liquid', canvases.liquid),
                solid: createSystem('solid', canvases.solid)
            };
        }

        function createSystem(type, canvas) {
            canvas.index = 0; // 重置排列索引
            return Array(config[type].count).fill().map(() => {
                const m = new Molecule(type, canvas);
                canvas.index = (canvas.index + 1) % 64;
                return m;
            });
        }

        // 温度控制
        const tempSlider = document.getElementById('tempSlider');
        const tempValue = document.getElementById('tempValue');

        function getSpeedFactor(temp) {
            return temp <= -273 ? 0 : Math.pow((temp + 273)/273, 0.7);
        }

        // 动画循环
        function animate() {
            Object.values(canvases).forEach(c => c.ctx.clearRect(0, 0, c.width, c.height));
            
            const currentTemp = parseFloat(tempSlider.value);
            const speedFactor = getSpeedFactor(currentTemp);
            
            Object.entries(systems).forEach(([type, molecules]) => {
                const gridSize = 50;
                const grid = {};
                
                molecules.forEach(molecule => molecule.update(speedFactor));
                
                molecules.forEach((molecule, index) => {
                    const gridX = Math.floor(molecule.x / gridSize);
                    const gridY = Math.floor(molecule.y / gridSize);
                    const key = `${gridX},${gridY}`;
                    
                    if (!grid[key]) grid[key] = [];
                    grid[key].forEach(other => molecule.checkCollision(other));
                    grid[key].push(molecule);
                });

                molecules.forEach(molecule => molecule.draw());
            });
            
            requestAnimationFrame(animate);
        }

        // 初始化画布
        function initCanvas(id, width, height) {
            const canvas = document.getElementById(id);
            canvas.width = width;
            canvas.height = height;
            return {
                ctx: canvas.getContext('2d'),
                width,
                height,
                index: 0
            };
        }

        // 事件监听
        tempSlider.addEventListener('input', function() {
            tempValue.textContent = `${this.value}℃`;
            tempValue.style.color = this.value >= 1000 ? '#ff3300' : 
                                  this.value <= -200 ? '#00ccff' : '#333';
            systems = createSystems(); // 温度变化时重新创建系统
        });

        // 启动动画
        animate();
    

物质三态分子运动模拟（增强版）

regular

✅ Low Risk - https://important-scarlet-dnvoyqku-dpnwsc9fcine.edgeone.dev/

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

Security Scan Report: important-scarlet-dnvoyqku-dpnwsc9fcine.edgeone.dev

Summary

AI Security Verdict

Low Risk

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