technology software

documentation technical

government public service

education learning

adult content

English

Domain 'muteq.pages.dev' uses the developer-focused generic top-level domain (.dev); it also runs on subdomain 'muteq'. Count 5 characters in 'pages' split between two vowels and three consonants. Word splitting yields one word: pages. No strong language cues emerged from the frequency lists.

_subject

_captcha

_template

_honey

name

organization

email

message

html/b6/0c/b60c6cf8-e95b-499c-813a-4a67159e4d14.html.gz

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

fbf80e9b0237ffe2e58132d3fcb124a4a62fbd17f9716418ccf865708c2344df

34a3a68f08db30a353802c5a762c5dcd89a168a1b56567019ef4a7563ceaf4d4

94ff7b608caf3b827ffa95bd6092b9d174732b856915b38ed006b4f049f95675

8a90b39b6c0d7faa70410cdd19348029a83a9f2d5f71e11b665a5f48330a4c72

45139faddd5aaf48ed2d62203d976e5cbd703db1a592de40527f9f6cf58abd44

ce1fa418de16a19495a9f72495580e3015d7745c296d3ce0485897f902ddedfb

56981604d66cccc26558c710afe08a15177030f8dd3842255d1cc53b4c9b7f3b

c25b7930e570e9ec56173cd3b866ec8d2e10016630db3937efb439daf1cedbf6

5cbf818e842628a4464e748594a6deae18ceddda3c2f541e7b3a0ff5fc7611e2

6157ef7bd9180dbaaf9dca31f02ba182e01e62d16a360347750df481ada1a35b

ff2c4b4d40b65933ed34a400a0934608c3fc011106ce7f27f74841460dba14b6

0c7c127214674b4ae3a92331af034474c66862cc4cc949538bf85d7246a1019c

viewport

MUTEQ PUHACH: smart counter-drone EW/ES system. Detect, analyze, neutralize hostile drones with software-defined precision.

description

MUTEQ — Software-Defined Counter-Drone EW

Smart EW/ES system that detects and neutralizes hostile drones autonomously.

html/b6/0c/b60c6cf8-e95b-499c-813a-4a67159e4d14_nodriver.html.gz

MUTEQ — Software-Defined Electronic Warfare

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


    import * as THREE from 'three';
    import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
    import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
    import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';

    (function() {
      const canvas = document.getElementById('hero-canvas');
      if (!canvas) return;

      // Skip on mobile for performance
      if (window.innerWidth < 768) return;

      const motionQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
      let prefersReduced = motionQuery.matches;
      motionQuery.addEventListener('change', (e) => { prefersReduced = e.matches; });

      const container = document.getElementById('hero-3d-container');

      const renderer = new THREE.WebGLRenderer({
        canvas,
        alpha: true,
        antialias: true,
        powerPreference: 'low-power',
      });
      renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));
      renderer.setSize(container.clientWidth, container.clientHeight);
      renderer.outputColorSpace = THREE.SRGBColorSpace;

      const scene = new THREE.Scene();
      scene.background = null;

      const camera = new THREE.PerspectiveCamera(45, container.clientWidth / container.clientHeight, 0.01, 100);
      camera.position.set(0, 1.2, 3.5);
      camera.lookAt(0, 0, 0);

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

      // Particles
      const PARTICLE_COUNT = 150;
      const particleGeo = new THREE.BufferGeometry();
      const positions = new Float32Array(PARTICLE_COUNT * 3);
      const basePositions = new Float32Array(PARTICLE_COUNT * 3);
      for (let i = 0; i < PARTICLE_COUNT; i++) {
        const theta = Math.random() * Math.PI * 2;
        const phi = Math.acos(2 * Math.random() - 1);
        const r = 1.5 + Math.random() * 1.5;
        const x = r * Math.sin(phi) * Math.cos(theta);
        const y = r * Math.sin(phi) * Math.sin(theta);
        const z = r * Math.cos(phi);
        positions[i * 3] = x;
        positions[i * 3 + 1] = y;
        positions[i * 3 + 2] = z;
        basePositions[i * 3] = x;
        basePositions[i * 3 + 1] = y;
        basePositions[i * 3 + 2] = z;
      }
      particleGeo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
      const particleMat = new THREE.PointsMaterial({
        color: 0x00ff41,
        size: 0.02,
        transparent: true,
        opacity: 0.4,
        blending: THREE.AdditiveBlending,
        depthWrite: false,
      });
      const particles = new THREE.Points(particleGeo, particleMat);
      scene.add(particles);

      // Mouse parallax
      let targetX = 0, targetY = 0;
      window.addEventListener('mousemove', (e) => {
        targetX = ((e.clientX / window.innerWidth) - 0.5) * 0.4;
        targetY = ((e.clientY / window.innerHeight) - 0.5) * -0.4;
      }, { passive: true });

      // Drag-to-rotate
      canvas.style.cursor = 'grab';
      let isDragging = false;
      let previousMouseX = 0;
      let previousMouseY = 0;
      let dragRotationX = 0;
      let dragRotationY = 0;

      canvas.addEventListener('mousedown', (e) => {
        isDragging = true;
        previousMouseX = e.clientX;
        previousMouseY = e.clientY;
        canvas.style.cursor = 'grabbing';
      });

      window.addEventListener('mouseup', () => {
        isDragging = false;
        canvas.style.cursor = 'grab';
      });

      window.addEventListener('mousemove', (e) => {
        if (isDragging) {
          const deltaX = e.clientX - previousMouseX;
          const deltaY = e.clientY - previousMouseY;
          dragRotationY += deltaX * 0.008;
          dragRotationX += deltaY * 0.005;
          dragRotationX = Math.max(-0.5, Math.min(0.5, dragRotationX));
          previousMouseX = e.clientX;
          previousMouseY = e.clientY;
        }
      });

      // Touch support
      canvas.addEventListener('touchstart', (e) => {
        if (e.touches.length === 1) {
          isDragging = true;
          previousMouseX = e.touches[0].clientX;
          previousMouseY = e.touches[0].clientY;
        }
      }, { passive: true });

      canvas.addEventListener('touchmove', (e) => {
        if (isDragging && e.touches.length === 1) {
          const deltaX = e.touches[0].clientX - previousMouseX;
          const deltaY = e.touches[0].clientY - previousMouseY;
          dragRotationY += deltaX * 0.008;
          dragRotationX += deltaY * 0.005;
          dragRotationX = Math.max(-0.5, Math.min(0.5, dragRotationX));
          previousMouseX = e.touches[0].clientX;
          previousMouseY = e.touches[0].clientY;
        }
      }, { passive: true });

      canvas.addEventListener('touchend', () => { isDragging = false; }, { passive: true });

      // Load model
      const loader = new GLTFLoader();
      const dracoLoader = new DRACOLoader();
      dracoLoader.setDecoderPath('https://cdn.jsdelivr.net/npm/three@0.170/examples/jsm/libs/draco/');
      loader.setDRACOLoader(dracoLoader);
      const ktx2Loader = new KTX2Loader();
      ktx2Loader.setTranscoderPath('https://cdn.jsdelivr.net/npm/three@0.170/examples/jsm/libs/basis/');
      ktx2Loader.detectSupport(renderer);
      loader.setKTX2Loader(ktx2Loader);

      loader.load(
        'https://pub-2464bfbf6f2f41b5abdaa5ecbb9444b5.r2.dev/model.glb',
        (gltf) => {
          const root = gltf.scene;
          const box = new THREE.Box3().setFromObject(root);
          const center = new THREE.Vector3();
          box.getCenter(center);
          root.position.sub(center);
          const size = new THREE.Vector3();
          box.getSize(size);
          const maxDim = Math.max(size.x, size.y, size.z);
          root.scale.setScalar(2.0 / maxDim);

          root.traverse((child) => {
            if (child.isMesh) {
              // Green wireframe fill
              child.material = new THREE.MeshBasicMaterial({
                color: 0x001a2e,
                transparent: true,
                opacity: 0.25,
                depthWrite: false,
              });
              // Add wireframe
              const wireMat = new THREE.MeshBasicMaterial({
                wireframe: true,
                color: 0x00ff41,
                transparent: true,
                opacity: 0.85,
              });
              const wireMesh = new THREE.Mesh(child.geometry, wireMat);
              wireMesh.position.copy(child.position);
              wireMesh.rotation.copy(child.rotation);
              wireMesh.scale.copy(child.scale);
              child.parent.add(wireMesh);
            }
          });

          hologramGroup.add(root);
          console.log('[hero-3d] Model loaded successfully, meshes:', root.children.length);
        },
        (progress) => {
          if (progress.total > 0) console.log('[hero-3d] Loading:', Math.round(progress.loaded / progress.total * 100) + '%');
        },
        (err) => { console.error('[hero-3d] GLB load FAILED:', err); }
      );

      // Resize
      function onResize() {
        camera.aspect = container.clientWidth / container.clientHeight;
        camera.updateProjectionMatrix();
        renderer.setSize(container.clientWidth, container.clientHeight);
      }
      let resizeTimer;
      window.addEventListener('resize', () => {
        clearTimeout(resizeTimer);
        resizeTimer = setTimeout(onResize, 150);
      });

      // Animation
      let baseRotation = Math.PI / 4;
      let frameCount = 0;
      let isVisible = true;

      const heroObserver = new IntersectionObserver((entries) => {
        isVisible = entries[0].isIntersecting;
      }, { threshold: 0 });
      heroObserver.observe(document.getElementById('hero'));

      function animate() {
        requestAnimationFrame(animate);
        if (document.hidden || !isVisible) return;

        const time = performance.now() * 0.001;

        if (!prefersReduced) {
          baseRotation += 0.002;
          hologramGroup.rotation.y = baseRotation + dragRotationY;
          hologramGroup.rotation.x = dragRotationX;
          hologramGroup.position.y = -0.25;

          camera.position.x += (targetX - camera.position.x) * 0.03;
          camera.position.y += (0.8 + targetY - camera.position.y) * 0.03;
          camera.lookAt(scene.position);

          frameCount++;
          if (frameCount % 3 === 0) {
            const pos = particleGeo.attributes.position.array;
            for (let i = 0; i < PARTICLE_COUNT; i++) {
              const phase = i * 0.7;
              pos[i * 3] = basePositions[i * 3] + Math.sin(time * 0.4 + phase) * 0.05;
              pos[i * 3 + 1] = basePositions[i * 3 + 1] + Math.cos(time * 0.3 + phase) * 0.05;
              pos[i * 3 + 2] = basePositions[i * 3 + 2] + Math.sin(time * 0.5 + phase) * 0.05;
            }
            particleGeo.attributes.position.needsUpdate = true;
          }
        }

        renderer.render(scene, camera);
      }

      animate();
    })();
  

Requests	IP Address	Location	AS Autonomous System
4	104.16.174.226	United States	AS13335Cloudflare, Inc.
4	142.250.187.195	United States	AS15169Google LLC
4	188.114.96.3	United States	AS13335Cloudflare, Inc.
4	142.251.208.170	United States	AS15169Google LLC
16	4	-	-

Security Scan Report: muteq.pages.dev

Summary

AI Security Verdict

Low 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

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