entertainment media

English

The domain name 'light-tomato-zxdth3vlfn-mwqzep53ma.edgeone.dev' uses the developer-focused generic top-level domain (.dev), featuring subdomain 'light-tomato-zxdth3vlfn-mwqzep53ma'. Count 7 characters in 'edgeone' holding four vowels versus three consonants. Tokenizing the label suggests two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/44/40/44409770-aadd-4483-866a-f0f8065e3a27.html.gz

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

76dea8151bc9352aef3528b4262e249b2604f62543828328db978d060d61a495

ec7851bfcd93ba6b76836457d522b1bd39b79b48bc2f9fa778efe58c1eca82d2

a77d4c248cbc2dc67d4b14359164d551cac0443a7c7b160043560bd80a25e5e3

viewport

child-src https:  chrome-untrusted://new-tab-page/ chrome-untrusted://ntp-microsoft-auth/;connect-src chrome://resources chrome://theme 'self';default-src 'self';font-src chrome://resources 'self';img-src chrome://resources chrome://theme chrome://image chrome://favicon2 chrome://app-icon chrome://extension-icon chrome://fileicon blob: data: 'self';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources chrome://webui-test 'self';style-src chrome://resources chrome://theme 'self' 'unsafe-inline';trusted-types parse-html-subset sanitize-inner-html static-types webui-test-script webui-test-html polymer-html-literal polymer-template-event-attribute-policy lit-html-desktop;frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;worker-src blob: 'self';frame-ancestors 'none';

html/44/40/44409770-aadd-4483-866a-f0f8065e3a27_nodriver.html.gz

Christmas Spiral Tree

Prudence Malinki

MarkMonitor Inc.

edgeone.dev

IRT-SG-ACE

ACE administrator

ACE-SG


    import * as THREE from 'three';
    const audio = document.getElementById('bgm');
    function startAudioFromSix() {
      const startAt = 0;
      const playAudio = () => {
        if (audio.readyState >= 1) {
          audio.currentTime = startAt;
        } else {
          audio.addEventListener('loadedmetadata', () => {
            audio.currentTime = startAt;
          }, { once: true });
        }
        audio.play().catch(() => {
          const resume = () => {
            audio.currentTime = startAt;
            audio.play();
            window.removeEventListener('pointerdown', resume);
          };
          window.addEventListener('pointerdown', resume, { once: true });
        });
      };
      playAudio();
    }
    window.addEventListener('load', startAudioFromSix);

    // ---------------- CONFIG ----------------
    const CONFIG = {
      bg: 0x000000,
      tree: {
        height: 24,
        radius: 10,
        // 母线向内弯曲：>1 越大越内凹（建议 2.2~3.2）
        coneCurve: 2.0,
        coils: 7.5,
      },
      garland: {
        segments: 2600,
        thickness: 3, // points per segment for thickness
      },
      bulbs: {
        count: 420,
      },
      sparkles: {
        count: 520,
      },
      background: {
        stars: 900,
      },
      star: {
        // center should overlap tree top
        rayYOffset: 1.1,
        coreYOffset: 0.15,
        rayScale: 30,
        coreScaleOuter: 5.2,
        coreScaleInner: 2.7
      }
    };

    const STATE = {
      rotX: 0,
      rotY: 0,
      drag: { active: false, lastX: 0, lastY: 0, lastT: 0 },
    };

    // ---------------- THREE SETUP ----------------
    const container = document.getElementById('canvas-container');

    const scene = new THREE.Scene();
    scene.background = new THREE.Color(CONFIG.bg);
    scene.fog = new THREE.FogExp2(CONFIG.bg, 0.018);

    const camera = new THREE.PerspectiveCamera(42, window.innerWidth / window.innerHeight, 0.1, 1000);
    camera.position.set(0, 2, 48);

    const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: false, powerPreference: 'high-performance' });
    renderer.setSize(window.innerWidth, window.innerHeight);
    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
    renderer.toneMapping = THREE.ACESFilmicToneMapping;
    renderer.toneMappingExposure = 1.38;
    renderer.outputColorSpace = THREE.SRGBColorSpace;
    container.appendChild(renderer.domElement);

    const mainGroup = new THREE.Group();
    scene.add(mainGroup);

    // Lights (gentle, since we rely on additive glow for most visuals)
    scene.add(new THREE.AmbientLight(0xffffff, 0.22));
    const key = new THREE.DirectionalLight(0xffe6bb, 0.55);
    key.position.set(20, 30, 30);
    scene.add(key);
    const fill = new THREE.PointLight(0xffcc88, 1.2, 80);
    fill.position.set(0, 10, 18);
    scene.add(fill);

    // ---------------- TEXTURES (procedural) ----------------
    function makeRadialGlowTexture({ size = 128, mid = 0.22, outer = 1.0 } = {}) {
      const c = document.createElement('canvas');
      c.width = c.height = size;
      const g = c.getContext('2d');
      const cx = size / 2, cy = size / 2;
      const grad = g.createRadialGradient(cx, cy, 0, cx, cy, size * 0.5);
      grad.addColorStop(0.0, 'rgba(255,255,255,1.0)');
      grad.addColorStop(mid, 'rgba(255,255,255,0.65)');
      grad.addColorStop(0.6, 'rgba(255,255,255,0.18)');
      grad.addColorStop(outer, 'rgba(255,255,255,0.0)');
      g.fillStyle = grad;
      g.fillRect(0, 0, size, size);
      const tex = new THREE.CanvasTexture(c);
      tex.colorSpace = THREE.SRGBColorSpace;
      return tex;
    }

    function makeSparkleTexture(size = 128, rays = 8) {
      const c = document.createElement('canvas');
      c.width = c.height = size;
      const g = c.getContext('2d');
      const cx = size / 2, cy = size / 2;

      // soft center
      const grad = g.createRadialGradient(cx, cy, 0, cx, cy, size / 2);
      grad.addColorStop(0.0, 'rgba(255,255,255,0.95)');
      grad.addColorStop(0.25, 'rgba(255,255,255,0.35)');
      grad.addColorStop(1.0, 'rgba(255,255,255,0.0)');
      g.fillStyle = grad;
      g.fillRect(0, 0, size, size);

      // crisp rays
      g.save();
      g.translate(cx, cy);
      g.globalCompositeOperation = 'lighter';
      for (let i = 0; i < rays; i++) {
        g.rotate((Math.PI * 2) / rays);
        const lg = g.createLinearGradient(0, 0, size / 2, 0);
        lg.addColorStop(0.0, 'rgba(255,255,255,0.0)');
        lg.addColorStop(0.12, 'rgba(255,255,255,0.85)');
        lg.addColorStop(0.35, 'rgba(255,255,255,0.25)');
        lg.addColorStop(1.0, 'rgba(255,255,255,0.0)');
        g.fillStyle = lg;
        g.fillRect(0, -2, size / 2, 4);
      }
      g.restore();

      const tex = new THREE.CanvasTexture(c);
      tex.colorSpace = THREE.SRGBColorSpace;
      return tex;
    }

    // Dynamic starburst canvas texture (ray width continuously changes)
    function makeDynamicStarburst(size = 512, rays = 18) {
      const c = document.createElement('canvas');
      c.width = c.height = size;
      const g = c.getContext('2d');
      const cx = size / 2, cy = size / 2;

      const phases = Array.from({ length: rays }, () => Math.random() * Math.PI * 2);
      const widths = Array.from({ length: rays }, () => 4 + Math.random() * 10); // base width
      const alphas = Array.from({ length: rays }, () => 0.55 + Math.random() * 0.4);

      function draw(timeSec) {
        g.clearRect(0, 0, size, size);
        g.save();
        g.translate(cx, cy);
        g.globalCompositeOperation = 'lighter';

        for (let i = 0; i < rays; i++) {
          const wobble = 0.65 + 0.35 * Math.sin(timeSec * (1.15 + 0.25 * (i % 5)) + phases[i]);
          const w = widths[i] * wobble;              // width changes smoothly
          const a = alphas[i] * (0.7 + 0.3 * wobble);// alpha changes smoothly

          g.save();
          g.rotate((Math.PI * 2 * i) / rays);

          const lg = g.createLinearGradient(0, 0, size / 2, 0);
          lg.addColorStop(0.0, `rgba(255,255,255,0.0)`);
          lg.addColorStop(0.10, `rgba(255,235,190,${0.95 * a})`);
          lg.addColorStop(0.28, `rgba(255,200,120,${0.35 * a})`);
          lg.addColorStop(1.0, `rgba(255,180,90,0.0)`);

          g.fillStyle = lg;
          // long thin strip with time-varying width
          g.fillRect(0, -w / 2, size / 2, w);

          g.restore();
        }
        g.restore();

        // Bright core (keep it tight)
        const core = g.createRadialGradient(cx, cy, 0, cx, cy, size * 0.16);
        core.addColorStop(0.0, 'rgba(255,255,255,1.0)');
        core.addColorStop(0.18, 'rgba(255,250,235,0.95)');
        core.addColorStop(0.45, 'rgba(255,230,170,0.22)');
        core.addColorStop(1.0, 'rgba(255,220,150,0.0)');
        g.fillStyle = core;
        g.fillRect(0, 0, size, size);
      }

      const tex = new THREE.CanvasTexture(c);
      tex.colorSpace = THREE.SRGBColorSpace;

      return { canvas: c, ctx: g, tex, draw, rays };
    }

    const texGlow = makeRadialGlowTexture({ size: 128, mid: 0.22 });
    const texGold = makeRadialGlowTexture({ size: 128, mid: 0.18 });
    const texSparkle = makeSparkleTexture(128, 8);
    const dynamicStar = makeDynamicStarburst(512, 18);

    // ---------------- TREE: GOLD GLITTER SPIRAL ----------------
    function concaveRadius(t) {
      // t in [0,1] bottom->top
      const base = CONFIG.tree.radius * Math.pow(1 - t, CONFIG.tree.coneCurve);
      // squeeze a touch so it looks like the reference
      const squeeze = 0.88 + 0.12 * Math.cos(Math.PI * t);
      return Math.max(base * squeeze, 0.22);
    }

    // Garland as Points (efficient)
    const garlandCount = CONFIG.garland.segments * CONFIG.garland.thickness;
    const garlandPos = new Float32Array(garlandCount * 3);
    const garlandCol = new Float32Array(garlandCount * 3);

    let ptr = 0;
    for (let i = 0; i < CONFIG.garland.segments; i++) {
      const t = i / (CONFIG.garland.segments - 1);
      const y = t * CONFIG.tree.height - CONFIG.tree.height / 2;

      const angle = t * (Math.PI * 2) * CONFIG.tree.coils;
      const r = concaveRadius(t);

      // Base on spiral
      const bx = Math.cos(angle) * r;
      const bz = Math.sin(angle) * r;

      // Tangent-ish direction for thickness jitter
      const tx = -Math.sin(angle);
      const tz = Math.cos(angle);

      for (let k = 0; k < CONFIG.garland.thickness; k++) {
        // Thickness: jitter around spiral
        const jitterT = (Math.random() - 0.5) * 0.45;
        const jitterR = (Math.random() - 0.5) * 0.22;
        const jitterY = (Math.random() - 0.5) * 0.18;

        const x = bx + tx * jitterT + Math.cos(angle) * jitterR;
        const z = bz + tz * jitterT + Math.sin(angle) * jitterR;

        garlandPos[ptr * 3 + 0] = x;
        garlandPos[ptr * 3 + 1] = y + jitterY;
        garlandPos[ptr * 3 + 2] = z;

        // Gold color with slight variation
        const warm = 0.76 + Math.random() * 0.24;
        garlandCol[ptr * 3 + 0] = 1.0;
        garlandCol[ptr * 3 + 1] = 0.82 * warm;
        garlandCol[ptr * 3 + 2] = 0.48 * warm;

        ptr++;
      }
    }

    const garlandGeo = new THREE.BufferGeometry();
    garlandGeo.setAttribute('position', new THREE.BufferAttribute(garlandPos, 3));
    garlandGeo.setAttribute('color', new THREE.BufferAttribute(garlandCol, 3));

    const garlandMat = new THREE.PointsMaterial({
      map: texGold,
      size: 0.28,
      sizeAttenuation: true,
      transparent: true,
      opacity: 0.95,
      blending: THREE.AdditiveBlending,
      vertexColors: true,
      depthWrite: false,
    });

    const garlandPoints = new THREE.Points(garlandGeo, garlandMat);
    mainGroup.add(garlandPoints);

    // Small sparkles along garland
    const sparkleGroup = new THREE.Group();
    mainGroup.add(sparkleGroup);

    const sparkleMat = new THREE.SpriteMaterial({
      map: texSparkle,
      color: 0xfff1c9,
      transparent: true,
      opacity: 0.8,
      blending: THREE.AdditiveBlending,
      depthWrite: false,
    });

    const sparkles = [];
    for (let i = 0; i < 520; i++) {
      const sp = new THREE.Sprite(sparkleMat.clone());
      const tt = Math.random();
      const angle = tt * (Math.PI * 2) * CONFIG.tree.coils + (Math.random() - 0.5) * 0.25;
      const y = tt * CONFIG.tree.height - CONFIG.tree.height / 2 + (Math.random() - 0.5) * 0.25;
      const r = concaveRadius(tt) + (Math.random() - 0.5) * 0.3;

      sp.position.set(Math.cos(angle) * r, y, Math.sin(angle) * r);
      const s = 0.55 + Math.random() * 1.15;
      sp.scale.set(s, s, 1);
      sp.material.opacity = 0.25 + Math.random() * 0.65;

      sparkleGroup.add(sp);
      sparkles.push({ sp, seed: Math.random() * 10, base: sp.material.opacity });
    }

    // Multi-color bulbs
    const bulbColors = [
      0x55ffdd, 0x66aaff, 0xff5577, 0xffdd66, 0xa66bff, 0x55ff66
    ];

    const bulbGroup = new THREE.Group();
    mainGroup.add(bulbGroup);

    const bulbs = [];
    for (let i = 0; i < CONFIG.bulbs.count; i++) {
      const c = bulbColors[(Math.random() * bulbColors.length) | 0];
      const mat = new THREE.SpriteMaterial({
        map: texGlow,
        color: c,
        transparent: true,
        opacity: 0.9,
        blending: THREE.AdditiveBlending,
        depthWrite: false,
      });
      const b = new THREE.Sprite(mat);

      const tt = Math.random();
      const y = tt * CONFIG.tree.height - CONFIG.tree.height / 2;
      const angle = Math.random() * Math.PI * 2;
      const r = concaveRadius(tt) * (1.00 + 0.10 * Math.random());
      b.position.set(Math.cos(angle) * r, y, Math.sin(angle) * r);

      const s = 0.55 + Math.random() * 1.0;
      b.scale.set(s, s, 1);

      bulbGroup.add(b);
      bulbs.push({ b, seed: Math.random() * 10, base: s, baseOp: mat.opacity });
    }

    // Top star: dynamic ray burst + very bright core, core moved down to overlap tree tip
    const treeTipY = CONFIG.tree.height / 2;

    const starBurst = new THREE.Sprite(new THREE.SpriteMaterial({
      map: dynamicStar.tex,
      color: 0xfff0c8,
      transparent: true,
      opacity: 0.95,
      blending: THREE.AdditiveBlending,
      depthWrite: false,
    }));
    starBurst.position.set(0, treeTipY + CONFIG.star.rayYOffset, 0);
    starBurst.scale.set(CONFIG.star.rayScale, CONFIG.star.rayScale, 1);
    mainGroup.add(starBurst);

    const starCoreOuter = new THREE.Sprite(new THREE.SpriteMaterial({
      map: texGlow,
      color: 0xffffff,
      transparent: true,
      opacity: 1.0,
      blending: THREE.AdditiveBlending,
      depthWrite: false,
    }));
    starCoreOuter.position.set(0, treeTipY + CONFIG.star.coreYOffset, 0);
    starCoreOuter.scale.set(CONFIG.star.coreScaleOuter, CONFIG.star.coreScaleOuter, 1);
    mainGroup.add(starCoreOuter);

    const starCoreInner = new THREE.Sprite(new THREE.SpriteMaterial({
      map: texGlow,
      color: 0xffffff,
      transparent: true,
      opacity: 1.0,
      blending: THREE.AdditiveBlending,
      depthWrite: false,
    }));
    starCoreInner.position.set(0, treeTipY + CONFIG.star.coreYOffset, 0);
    starCoreInner.scale.set(CONFIG.star.coreScaleInner, CONFIG.star.coreScaleInner, 1);
    mainGroup.add(starCoreInner);

    // Background star field
    const bgCount = CONFIG.background.stars;
    const bgPos = new Float32Array(bgCount * 3);
    const bgCol = new Float32Array(bgCount * 3);
    for (let i = 0; i < bgCount; i++) {
      const r = 30 + Math.random() * 110;
      const theta = Math.random() * Math.PI * 2;
      const phi = Math.acos(2 * Math.random() - 1);
      bgPos[i * 3 + 0] = r * Math.sin(phi) * Math.cos(theta);
      bgPos[i * 3 + 1] = r * Math.cos(phi);
      bgPos[i * 3 + 2] = r * Math.sin(phi) * Math.sin(theta);

      const w = 0.7 + Math.random() * 0.3;
      bgCol[i * 3 + 0] = w;
      bgCol[i * 3 + 1] = w;
      bgCol[i * 3 + 2] = w;
    }
    const bgGeo = new THREE.BufferGeometry();
    bgGeo.setAttribute('position', new THREE.BufferAttribute(bgPos, 3));
    bgGeo.setAttribute('color', new THREE.BufferAttribute(bgCol, 3));
    const bgMat = new THREE.PointsMaterial({
      map: texGold,
      size: 0.18,
      transparent: true,
      opacity: 0.55,
      blending: THREE.AdditiveBlending,
      vertexColors: true,
      depthWrite: false,
    });
    const bg = new THREE.Points(bgGeo, bgMat);
    scene.add(bg);

    // ---------------- INTERACTION: touch/mouse drag rotate ----------------
    function onPointerDown(e) {
      STATE.drag.active = true;
      STATE.drag.lastX = e.clientX;
      STATE.drag.lastY = e.clientY;
      STATE.drag.lastT = performance.now();
      renderer.domElement.setPointerCapture?.(e.pointerId);
    }
    function onPointerMove(e) {
      if (!STATE.drag.active) return;
      const dx = e.clientX - STATE.drag.lastX;
      const dy = e.clientY - STATE.drag.lastY;
      STATE.drag.lastX = e.clientX;
      STATE.drag.lastY = e.clientY;
      STATE.drag.lastT = performance.now();

      STATE.rotY += dx * 0.005;
      STATE.rotX += dy * 0.003;
      STATE.rotX = THREE.MathUtils.clamp(STATE.rotX, -0.9, 0.9);
    }
    function onPointerUp() {
      STATE.drag.active = false;
    }

    renderer.domElement.addEventListener('pointerdown', onPointerDown, { passive: true });
    renderer.domElement.addEventListener('pointermove', onPointerMove, { passive: true });
    renderer.domElement.addEventListener('pointerup', onPointerUp, { passive: true });
    renderer.domElement.addEventListener('pointercancel', onPointerUp, { passive: true });

    // Resize
    window.addEventListener('resize', () => {
      camera.aspect = window.innerWidth / window.innerHeight;
      camera.updateProjectionMatrix();
      renderer.setSize(window.innerWidth, window.innerHeight);
      renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
    });

    // Loader fadeout after first frames
    const loaderEl = document.getElementById('loader');
    let loaderGone = false;
 
    function hideLoaderSoon() {
      if (loaderGone) return;
      loaderGone = true;
      loaderEl.style.opacity = '0';
      setTimeout(() => loaderEl.remove(), 900);
    }

    // ---------------- ANIMATION ----------------
    const clock = new THREE.Clock();
    let frame = 0;

    function animate() {
      requestAnimationFrame(animate);
      const t = clock.getElapsedTime();
      frame++;

      // update starburst ray widths continuously (but not every single frame for perf)
      if (frame % 2 === 0) {
        dynamicStar.draw(t);
        dynamicStar.tex.needsUpdate = true;
      }

      // Auto rotate when not dragging
      const recentlyDragged = (performance.now() - STATE.drag.lastT) < 250;
      if (!STATE.drag.active && !recentlyDragged) {
        STATE.rotY += 0.12 * 0.016;
        STATE.rotX += (0 - STATE.rotX) * 0.02;
      }

      mainGroup.rotation.y = STATE.rotY;
      mainGroup.rotation.x = STATE.rotX;

      // Twinkle sparkles
      for (const s of sparkles) {
        const tw = 0.55 + 0.45 * Math.sin(t * 3.2 + s.seed);
        s.sp.material.opacity = Math.min(1, s.base * tw);
        const sc = (0.9 + 0.35 * Math.sin(t * 4.1 + s.seed * 2.0));
        s.sp.scale.setScalar(sc);
      }

      // Bulb pulse
      for (const o of bulbs) {
        const p = 0.82 + 0.18 * Math.sin(t * 3.5 + o.seed);
        o.b.scale.setScalar(o.base * p);
        o.b.material.opacity = o.baseOp * (0.75 + 0.25 * p);
      }

      // Star rotation + breath; keep core VERY bright
      const breathe = 0.92 + 0.10 * Math.sin(t * 2.1);
      starBurst.material.opacity = 0.86 + 0.14 * Math.sin(t * 1.8);
      starBurst.scale.set(CONFIG.star.rayScale * breathe, CONFIG.star.rayScale * breathe, 1);
      starBurst.material.rotation = t * 0.10;

      // core brightness (tight, strong)
      starCoreOuter.material.opacity = 1.0;
      starCoreOuter.scale.setScalar(CONFIG.star.coreScaleOuter * (0.95 + 0.08 * Math.sin(t * 2.4)));
      starCoreInner.material.opacity = 1.0;
      starCoreInner.scale.setScalar(CONFIG.star.coreScaleInner * (0.92 + 0.10 * Math.sin(t * 2.9)));

      // Background slight drift
      bg.rotation.y = t * 0.01;

      renderer.render(scene, camera);

      // hide loader right after first successful render
      if (!loaderGone && frame > 2) hideLoaderSoon();
    }

    animate();
  

✅ Low Risk - https://light-tomato-zxdth3vlfn-mwqzep53ma.edgeone.dev/

Requests	IP Address	Location	AS Autonomous System
1	43.174.246.29	Singapore	AS139341ACE
1	142.251.140.170	United States	AS15169GOOGLE
1	172.217.18.3	United States	AS15169GOOGLE
1	137.220.223.142	Singapore	Unknown
1	43.174.247.29	Singapore	AS139341ACE
1	14.128.63.75	Singapore	Unknown
6	6	-	-

Security Scan Report: light-tomato-zxdth3vlfn-mwqzep53ma.edgeone.dev

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

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