cryptocurrency blockchain

technology software

social media network

documentation technical

entertainment media

Chinese

Domain 'native-tan-jnp8pwpdcs-g3hxf4zw0q.edgeone.app' uses the application-focused generic top-level domain (.app); it also runs on subdomain 'native-tan-jnp8pwpdcs-g3hxf4zw0q'. Its registrable label 'edgeone' stretches across 7 characters split between four vowels and 3 consonants. Segmentation suggests 2 words: edge, one. Expect 3.5 characters per word on average. No strong language cues emerged from the frequency lists.

html/06/0e/060e1e4b-483b-4591-81f4-eea425bb04c1.html.gz

d234e578618fa816955ebdc059c049c577e203e650e33cf22bde3f232c29e669

8f09315c0cec117a0ca2494d3e3586035b3c4323d6dcb037537cc51b04c3cdba

857061a12a014e5f6447582a4d2eb6d45547e2684bb5f170ca426e532bfe5b90

ef5c33eb93a1e3638bd53a2c84224486578ed3c8479976a8985447e7d734fb99

3b28a1ee27e0eb96c0eab137a1f442ccf127a926904eced2d51e125ec44af781

4e3346db194db56a596cd074e9bdb39fb5eb52040c333e0d29dc4eb1324d3b1d

328cf7db0da5d9be83ffe39d54b01d5ac1fddf108cc98182ddbb056f5c8b537f

1c90c085312871c4bcdccfcf519499c6276dd503363fcf7cb7f703add45cf4a2

853f15d0337da0854d6f0c9e65a57312aed19cf11d9f11f92bc255a45195540e

57de46c2601ab4f14697608d0825eb0db6d53eae0614365e9ffc90de188790c2

ce0f5e5d008c9f07f46fb22ce98604faa2e77c1a0d57dd81cba1220197a8fdf4

201b327a8b6eb836d597096fc66cb1979a8d4a1b86fda56a9451dfe6493aa26e

viewport

Prudence Malinki

MarkMonitor Inc.

edgeone.app

Abuse Account

Fastly RIR Administrator

Fastly Network Operations

Fastly, Inc.

SKYCA-3


import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';

// ── Scene, Camera, Renderer ──
const scene = new THREE.Scene();

const camera = new THREE.PerspectiveCamera(45, innerWidth / innerHeight, 0.1, 200);
camera.position.set(0, 3.5, 9);
camera.lookAt(0, 0, 0);

const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
renderer.setSize(innerWidth, innerHeight);
renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
renderer.toneMapping = THREE.ACESFilmicToneMapping;
renderer.toneMappingExposure = 1.2;
document.body.appendChild(renderer.domElement);

const composer = new EffectComposer(renderer);
composer.addPass(new RenderPass(scene, camera));
const bloomPass = new UnrealBloomPass(
  new THREE.Vector2(innerWidth, innerHeight), 0.5, 0.2, 0.1
);
bloomPass.threshold = 0.1;
bloomPass.strength = 0.8;
bloomPass.radius = 0.3;
composer.addPass(bloomPass);

// ── Stars ──
const starsGeo = new THREE.BufferGeometry();
const starsCount = 2000;
const starsPos = new Float32Array(starsCount * 3);
for (let i = 0; i < starsCount; i++) {
  const theta = Math.random() * Math.PI * 2;
  const phi = Math.acos(2 * Math.random() - 1);
  const r = 50 + Math.random() * 20;
  starsPos[i * 3] = r * Math.sin(phi) * Math.cos(theta);
  starsPos[i * 3 + 1] = r * Math.sin(phi) * Math.sin(theta);
  starsPos[i * 3 + 2] = r * Math.cos(phi);
}
starsGeo.setAttribute('position', new THREE.BufferAttribute(starsPos, 3));
const stars = new THREE.Points(starsGeo, new THREE.PointsMaterial({
  color: 0xffffff, size: 0.06, blending: THREE.AdditiveBlending,
  depthWrite: false, transparent: true, opacity: 0.8,
}));
scene.add(stars);

// ── Lighting ──
scene.add(new THREE.AmbientLight(0x1e293b, 0.6));
const sunLight = new THREE.DirectionalLight(0xffffff, 2.5);
sunLight.position.set(8, 3, 5);
scene.add(sunLight);

// ── Earth ──
const earthGroup = new THREE.Group();
scene.add(earthGroup);
const earthGeo = new THREE.SphereGeometry(1, 64, 64);
const EARTH_RADIUS = 1.0;

// Load real Earth texture, fall back to procedural
const textureLoader = new THREE.TextureLoader();

function createProceduralEarthTexture() {
  const canvas = document.createElement('canvas');
  canvas.width = 2048; canvas.height = 1024;
  const ctx = canvas.getContext('2d');

  const oceanGrad = ctx.createRadialGradient(0, 0, 0, 0, 0, 400);
  oceanGrad.addColorStop(0, '#1e3a5f'); oceanGrad.addColorStop(0.5, '#1a3a6b'); oceanGrad.addColorStop(1, '#0f2247');
  ctx.fillStyle = oceanGrad; ctx.fillRect(0, 0, 2048, 1024);

  ctx.fillStyle = '#1a4a1a';
  for (let i = 0; i < 18; i++) {
    ctx.beginPath();
    ctx.ellipse(Math.random() * 2048, Math.random() * 1024, 60 + Math.random() * 250, 40 + Math.random() * 180, Math.random() * Math.PI, 0, Math.PI * 2);
    ctx.fill();
  }
  ctx.fillStyle = '#2d6b2d';
  for (let i = 0; i < 30; i++) {
    ctx.beginPath();
    ctx.ellipse(Math.random() * 2048, Math.random() * 1024, 30 + Math.random() * 80, 20 + Math.random() * 60, Math.random() * Math.PI, 0, Math.PI * 2);
    ctx.fill();
  }
  ctx.fillStyle = '#e8f0f8';
  ctx.beginPath(); ctx.ellipse(1024, 0, 800, 120, 0, 0, Math.PI * 2); ctx.fill();
  ctx.beginPath(); ctx.ellipse(1024, 1024, 800, 120, 0, 0, Math.PI * 2); ctx.fill();

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

const earthMat = new THREE.MeshStandardMaterial({
  roughness: 0.75, metalness: 0.05,
});

// Try loading real NASA Blue Marble texture, fallback to procedural
const EARTH_TEX_URL = 'https://unpkg.com/three-globe/example/img/earth-blue-marble.jpg';

function hideLoading() {
  const el = document.getElementById('loading');
  if (el) { el.style.opacity = '0'; setTimeout(() => el.remove(), 500); }
}

// Safety timeout: hide loading indicator after 8s no matter what
const loadingTimeout = setTimeout(hideLoading, 8000);

textureLoader.load(
  EARTH_TEX_URL,
  (tex) => {
    clearTimeout(loadingTimeout);
    tex.colorSpace = THREE.SRGBColorSpace;
    earthMat.map = tex;
    earthMat.needsUpdate = true;
    hideLoading();
  },
  undefined,
  () => {
    clearTimeout(loadingTimeout);
    earthMat.map = createProceduralEarthTexture();
    earthMat.needsUpdate = true;
    hideLoading();
  }
);

const earth = new THREE.Mesh(earthGeo, earthMat);
earthGroup.add(earth);

// Atmosphere glow
const atmoGeo = new THREE.SphereGeometry(1.015, 64, 64);
const atmoMat = new THREE.ShaderMaterial({
  vertexShader: `
    varying vec3 vNormal; varying vec3 vPosition;
    void main() {
      vNormal = normalize(normalMatrix * normal);
      vPosition = (modelViewMatrix * vec4(position, 1.0)).xyz;
      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
    }`,
  fragmentShader: `
    varying vec3 vNormal; varying vec3 vPosition;
    void main() {
      vec3 viewDir = normalize(-vPosition);
      float rim = 1.0 - abs(dot(vNormal, viewDir));
      float glow = pow(rim, 3.5) * 0.35;
      gl_FragColor = vec4(0.4, 0.65, 0.95, glow);
    }`,
  transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
});
earthGroup.add(new THREE.Mesh(atmoGeo, atmoMat));

// ── Ground stations (fixed points on Earth surface) ──
const groundStations = [];
const GW_COUNT = 40;

function latLonToVec3(lat, lon, radius) {
  const phi = THREE.MathUtils.degToRad(90 - lat);
  const theta = THREE.MathUtils.degToRad(lon);
  return new THREE.Vector3(
    -radius * Math.sin(phi) * Math.cos(theta),
    radius * Math.cos(phi),
    radius * Math.sin(phi) * Math.sin(theta)
  );
}

// Major city / gateway locations (lat, lon)
const GW_LOCATIONS = [
  [40.7, -74.0], [51.5, -0.1], [35.7, 139.7], [-33.9, 151.2],
  [55.8, 37.6], [48.9, 2.3], [-23.5, -46.6], [19.0, 72.8],
  [31.2, 121.5], [39.9, 116.4], [37.6, 127.0], [1.3, 103.8],
  [25.2, 55.3], [-1.3, 36.8], [-26.2, 28.0], [30.0, 31.2],
  [52.5, 13.4], [41.0, 29.0], [59.3, 18.1], [60.2, 24.9],
  [45.4, -75.7], [43.6, -79.4], [34.1, -118.2], [41.9, -87.6],
  [29.8, -95.4], [33.4, -112.1], [47.6, -122.3], [38.9, -77.0],
  [53.5, -113.5], [51.0, -114.1], [22.3, 114.2], [13.8, 100.5],
  [28.6, 77.2], [12.9, 77.6], [6.5, 3.4], [-34.6, -58.4],
  [14.6, -90.5], [4.7, -74.1], [10.5, -66.9], [25.0, -77.3],
];

const gwGroup = new THREE.Group();
const gwGlowGroup = new THREE.Group();
scene.add(gwGroup);
scene.add(gwGlowGroup);

GW_LOCATIONS.forEach(([lat, lon]) => {
  const pos = latLonToVec3(lat, lon, EARTH_RADIUS * 1.002);
  const gwDot = new THREE.Mesh(
    new THREE.SphereGeometry(0.012, 8, 8),
    new THREE.MeshBasicMaterial({ color: 0x22d3ee })
  );
  gwDot.position.copy(pos);
  gwGroup.add(gwDot);

  // Glow ring
  const ringGeo = new THREE.RingGeometry(0.014, 0.022, 32);
  const ring = new THREE.Mesh(ringGeo, new THREE.MeshBasicMaterial({
    color: 0x22d3ee, side: THREE.DoubleSide,
    transparent: true, opacity: 0.7, depthWrite: false,
  }));
  ring.position.copy(pos);
  ring.lookAt(new THREE.Vector3(0, 0, 0));
  gwGlowGroup.add(ring);

  groundStations.push({ position: pos, ring });
});

// Add random additional stations for coverage
for (let i = 0; i < 20; i++) {
  const lat = (Math.random() - 0.5) * 120;
  const lon = Math.random() * 360 - 180;
  const pos = latLonToVec3(lat, lon, EARTH_RADIUS * 1.002);
  const gwDot = new THREE.Mesh(
    new THREE.SphereGeometry(0.008, 6, 6),
    new THREE.MeshBasicMaterial({ color: 0x67e8f9 })
  );
  gwDot.position.copy(pos);
  gwGroup.add(gwDot);
  groundStations.push({ position: pos, ring: null });
}

document.getElementById('gwCount').textContent = GW_LOCATIONS.length + 20;

// ── Starlink Constellation ──
const SHELLS = [
  { r: 1.08, perOrbit: 22, orbitCount: 18, inc: 53,    color: 0xfacc15, colorName: 'yellow',  speed: 0.60 },
  { r: 1.12, perOrbit: 22, orbitCount: 18, inc: 53.2,  color: 0xfbbf24, colorName: 'amber',   speed: 0.55 },
  { r: 1.18, perOrbit: 20, orbitCount: 36, inc: 53,    color: 0x4ade80, colorName: 'green',   speed: 0.50 },
  { r: 1.22, perOrbit: 20, orbitCount: 36, inc: 53.2,  color: 0x60a5fa, colorName: 'blue',    speed: 0.45 },
  { r: 1.26, perOrbit: 18, orbitCount: 36, inc: 70,    color: 0x818cf8, colorName: 'indigo',  speed: 0.45 },
  { r: 1.30, perOrbit: 18, orbitCount: 22, inc: 97.6,  color: 0xa78bfa, colorName: 'purple',  speed: 0.48 },
  { r: 1.34, perOrbit: 15, orbitCount: 10, inc: 97.6,  color: 0xc084fc, colorName: 'violet',  speed: 0.42 },
];

const satelliteGroups = [];
const allSatellites = [];
let totalSatellites = 0;

function createOrbitRing(radius, color) {
  const pts = [];
  for (let i = 0; i <= 128; i++) {
    const angle = (i / 128) * Math.PI * 2;
    pts.push(new THREE.Vector3(Math.cos(angle) * radius, 0, Math.sin(angle) * radius));
  }
  return new THREE.Line(
    new THREE.BufferGeometry().setFromPoints(pts),
    new THREE.LineBasicMaterial({ color, transparent: true, opacity: 0.18, depthWrite: false, blending: THREE.AdditiveBlending })
  );
}

SHELLS.forEach((shell) => {
  const group = new THREE.Group();
  const orbitLines = new THREE.Group();
  const laserLines = new THREE.Group();
  const { r, perOrbit, orbitCount, inc, color, speed } = shell;
  const satellitesInShell = [];

  // Downlink beams buffer: 2 verts per satellite
  const beamCount = perOrbit * orbitCount;
  const beamPositions = new Float32Array(beamCount * 2 * 3); // 2 points × 3 coords
  const beamGeo = new THREE.BufferGeometry();
  beamGeo.setAttribute('position', new THREE.BufferAttribute(beamPositions, 3));
  const beamMat = new THREE.LineBasicMaterial({
    color: new THREE.Color(color).multiplyScalar(0.7),
    transparent: true, opacity: 0.22,
    depthWrite: false, blending: THREE.AdditiveBlending,
  });
  const beamLines = new THREE.LineSegments(beamGeo, beamMat);
  beamLines.frustumCulled = false;

  for (let o = 0; o < orbitCount; o++) {
    const raan = (o / orbitCount) * Math.PI * 2;

    const ring = createOrbitRing(r, color);
    ring.rotation.x = -THREE.MathUtils.degToRad(inc);
    ring.rotation.y = raan;
    orbitLines.add(ring);

    for (let s = 0; s < perOrbit; s++) {
      const phase = (s / perOrbit) * Math.PI * 2 + o * 0.15;
      const sat = new THREE.Mesh(
        new THREE.SphereGeometry(0.008, 4, 4),
        new THREE.MeshBasicMaterial({ color })
      );
      sat.userData = { radius: r, inclination: inc, raan, phase, speed, shellColor: color };
      group.add(sat);
      satellitesInShell.push(sat);
      allSatellites.push(sat);
      totalSatellites++;
    }
  }

  // Laser links
  const laserMat = new THREE.LineBasicMaterial({
    color: 0xf472b6, transparent: true, opacity: 0.15,
    depthWrite: false, blending: THREE.AdditiveBlending,
  });
  for (let o = 0; o < orbitCount; o++) {
    const start = o * perOrbit;
    const planeSats = satellitesInShell.slice(start, start + perOrbit);
    for (let s = 0; s < planeSats.length; s++) {
      const next = planeSats[(s + 1) % planeSats.length];
      const laserLine = new THREE.Line(new THREE.BufferGeometry(), laserMat);
      laserLine.userData = { satA: planeSats[s], satB: next };
      laserLine.frustumCulled = false;
      laserLines.add(laserLine);
    }
  }

  satelliteGroups.push({
    group, satellites: satellitesInShell, laserLines,
    beamLines, beamGeo, beamCount,
  });
  scene.add(group);
  scene.add(orbitLines);
  scene.add(laserLines);
  scene.add(beamLines);
});

document.getElementById('satCount').textContent = totalSatellites;
document.getElementById('incCover').textContent = '53° / 70° / 97.6°';

// ── Equatorial reference rings ──
SHELLS.forEach(s => {
  const torus = new THREE.Mesh(
    new THREE.TorusGeometry(s.r, 0.002, 8, 128),
    new THREE.MeshBasicMaterial({ color: s.color, transparent: true, opacity: 0.25, depthWrite: false, blending: THREE.AdditiveBlending })
  );
  torus.rotation.x = Math.PI / 2;
  scene.add(torus);
});

// ── Orbit Controls ──
const controls = new OrbitControls(camera, renderer.domElement);
controls.enableDamping = true;
controls.dampingFactor = 0.08;
controls.minDistance = 1.8;
controls.maxDistance = 30;
controls.target.set(0, 0, 0);
controls.autoRotate = true;
controls.autoRotateSpeed = 0.15;
controls.update();

// ── Helper: compute satellite world position ──
function computeSatPosition(sat) {
  const { radius, inclination, raan, speed } = sat.userData;
  const incRad = THREE.MathUtils.degToRad(inclination);
  const theta = sat.userData.phase;

  const x0 = Math.cos(theta) * radius;
  const z0 = Math.sin(theta) * radius;
  const y = -z0 * Math.sin(incRad);
  const z = z0 * Math.cos(incRad);
  const x = x0 * Math.cos(raan) - z * Math.sin(raan);
  const zFinal = x0 * Math.sin(raan) + z * Math.cos(raan);

  return new THREE.Vector3(x, y, zFinal);
}

// ── Active ground station tracking ──
// For each ground station, find the nearest N satellites and highlight the connection
const activeGwBeams = [];
const MAX_GW_BEAMS = 80;
const gwBeamGroup = new THREE.Group();
scene.add(gwBeamGroup);

// Pre-create beam line objects
for (let i = 0; i < MAX_GW_BEAMS; i++) {
  const line = new THREE.Line(
    new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(), new THREE.Vector3()]),
    new THREE.LineBasicMaterial({
      color: 0x22d3ee, transparent: true, opacity: 0.35,
      depthWrite: false, blending: THREE.AdditiveBlending,
    })
  );
  line.frustumCulled = false;
  line.visible = false;
  gwBeamGroup.add(line);
  activeGwBeams.push(line);
}

// ── Animation ──
const clock = new THREE.Clock();

function animate() {
  const dt = Math.min(clock.getDelta(), 0.1);
  controls.update();
  earthGroup.rotation.y += dt * 0.08;

  satelliteGroups.forEach(({ group, satellites, laserLines, beamLines, beamGeo, beamCount }) => {
    // Update satellite positions
    satellites.forEach(sat => {
      sat.userData.phase += dt * sat.userData.speed * 0.75;
      sat.position.copy(computeSatPosition(sat));
    });

    // Update laser links
    laserLines.children.forEach(line => {
      if (!line.userData.satA || !line.userData.satB) return;
      const a = line.userData.satA.position;
      const b = line.userData.satB.position;
      if (a.distanceTo(b) < 0.45) {
        line.geometry.dispose();
        line.geometry = new THREE.BufferGeometry().setFromPoints([a, b]);
        line.visible = true;
      } else {
        line.visible = false;
      }
    });

    // Update downlink beams (satellite → nadir on Earth surface)
    const posArr = beamGeo.attributes.position.array;
    for (let i = 0; i < beamCount; i++) {
      const sat = satellites[i];
      const satPos = sat.position;
      // Nadir = normalize(satPos) * EARTH_RADIUS
      const len = satPos.length();
      const nadirX = (satPos.x / len) * EARTH_RADIUS;
      const nadirY = (satPos.y / len) * EARTH_RADIUS;
      const nadirZ = (satPos.z / len) * EARTH_RADIUS;

      const idx = i * 6;
      posArr[idx] = satPos.x;
      posArr[idx + 1] = satPos.y;
      posArr[idx + 2] = satPos.z;
      posArr[idx + 3] = nadirX;
      posArr[idx + 4] = nadirY;
      posArr[idx + 5] = nadirZ;
    }
    beamGeo.attributes.position.needsUpdate = true;
  });

  // Update active ground station → satellite connections
  // Pick nearest satellite for each ground station
  const maxDist = 0.55; // max distance to show connection
  let beamIdx = 0;
  for (let g = 0; g < groundStations.length && beamIdx < MAX_GW_BEAMS; g++) {
    const gw = groundStations[g];
    // Find nearest visible satellite
    let bestSat = null;
    let bestDist = Infinity;
    // Only sample a subset for performance
    const step = Math.max(1, Math.floor(allSatellites.length / 300));
    for (let s = 0; s < allSatellites.length; s += step) {
      const sat = allSatellites[s];
      const d = gw.position.distanceTo(sat.position);
      if (d < bestDist) { bestDist = d; bestSat = sat; }
    }
    if (bestSat && bestDist < maxDist) {
      const line = activeGwBeams[beamIdx];
      line.visible = true;
      const geo = new THREE.BufferGeometry().setFromPoints([gw.position, bestSat.position]);
      line.geometry.dispose();
      line.geometry = geo;
      line.material.opacity = 0.15 + (1 - bestDist / maxDist) * 0.45;
      beamIdx++;
    }
  }
  // Hide remaining
  for (let i = beamIdx; i < MAX_GW_BEAMS; i++) {
    activeGwBeams[i].visible = false;
  }

  stars.rotation.y += dt * 0.015;
  composer.render();
  requestAnimationFrame(animate);
}

animate();

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


星链计划 · Starlink Constellation

✅ Low Risk - https://native-tan-jnp8pwpdcs-g3hxf4zw0q.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
6	43.152.26.58	Singapore	AS139341ACE
6	104.16.175.226	United States	AS13335Cloudflare, Inc.
12	2	-	-

Security Scan Report: native-tan-jnp8pwpdcs-g3hxf4zw0q.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

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