Portuguese

Domain 'swift-aquamarine-wlftjzo0u6-qy8ag2m587.edgeone.app' uses the application-focused generic top-level domain (.app) and includes subdomain 'swift-aquamarine-wlftjzo0u6-qy8ag2m587'. The core label 'edgeone' covers 7 characters holding 4 vowels versus three 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/21/70/21700e05-db0f-435f-a3a5-0ac7cd90ccdb_fallback.html.gz

Manual de Manutenção - Motor Radial

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

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';

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';

base-uri 'none';child-src https:;form-action https://ogs.google.com https://*.corp.google.com;object-src 'none';script-src 'self' 'unsafe-inline' https:;frame-ancestors chrome://new-tab-page/


      AFRAME.registerComponent('manipulador-gestos', {
        schema: {
          enabled: { default: true },
          rotationFactor: { default: 5 }, // Sensibilidade da rotação
          minScale: { default: 0.01 },
          maxScale: { default: 8 },
        },

        init: function () {
          this.handleScale = this.handleScale.bind(this);
          this.handleRotation = this.handleRotation.bind(this);
          this.isVisible = false;
          this.initialScale = this.el.object3D.scale.clone();
          this.scaleFactor = 1;

          this.el.sceneEl.addEventListener("markerFound", (e) => {
            this.isVisible = true;
          });

          this.el.sceneEl.addEventListener("markerLost", (e) => {
            this.isVisible = false;
          });
        },

        update: function () {
          if (this.data.enabled) {
            this.el.sceneEl.addEventListener("onefingermove", this.handleRotation);
            this.el.sceneEl.addEventListener("twofingermove", this.handleScale);
          } else {
            this.el.sceneEl.removeEventListener("onefingermove", this.handleRotation);
            this.el.sceneEl.removeEventListener("twofingermove", this.handleScale);
          }
        },

        handleRotation: function (event) {
          if (this.isVisible) {
            // AQUI ESTÁ A CORREÇÃO DA ROTAÇÃO:
            // Multiplicamos por valores positivos ou negativos para inverter a direção conforme seu pedido.
            
            // Eixo X (Arrastar para cima/baixo) -> Gira no eixo X
            // Se estava invertido, mudamos o sinal aqui.
            this.el.object3D.rotation.x += event.detail.positionChange.y * this.data.rotationFactor; 

            // Eixo Y (Arrastar para lados) -> Gira no eixo Y
            this.el.object3D.rotation.y += event.detail.positionChange.x * this.data.rotationFactor; 
          }
        },

        handleScale: function (event) {
          if (this.isVisible) {
            this.scaleFactor *= 1 + event.detail.spreadChange / event.detail.startSpread;
            this.scaleFactor = Math.min(Math.max(this.scaleFactor, this.data.minScale), this.data.maxScale);

            this.el.object3D.scale.x = this.scaleFactor * this.initialScale.x;
            this.el.object3D.scale.y = this.scaleFactor * this.initialScale.y;
            this.el.object3D.scale.z = this.scaleFactor * this.initialScale.z;
          }
        }
      });
      
      // Detector de gestos (Necessário para o manipulador funcionar)
      AFRAME.registerComponent('gesture-detector', {
        schema: { element: { default: '' } },
        init: function() {
          this.targetElement = this.data.element && document.querySelector(this.data.element);
          if (!this.targetElement) { this.targetElement = this.el; }
          this.internalState = { previousState: null };
          this.emitGestureEvent = this.emitGestureEvent.bind(this);
          this.targetElement.addEventListener("touchstart", this.emitGestureEvent);
          this.targetElement.addEventListener("touchend", this.emitGestureEvent);
          this.targetElement.addEventListener("touchmove", this.emitGestureEvent);
        },
        emitGestureEvent: function(event) {
          const currentState = this.getTouchState(event);
          const previousState = this.internalState.previousState;
          const gestureContinues = previousState && currentState && currentState.touchCount == previousState.touchCount;
          const gestureEnded = previousState && !gestureContinues;
          const gestureStarted = currentState && !gestureContinues;

          if (gestureEnded) { this.el.emit("gestureend"); }
          if (gestureStarted) { this.el.emit("gesturestart"); }
          if (gestureContinues) {
            const detail = {
              positionChange: {
                x: currentState.position.x - previousState.position.x,
                y: currentState.position.y - previousState.position.y
              },
              spreadChange: currentState.spread - previousState.spread,
              startSpread: previousState.spread,
              position: currentState.position
            };
            if (currentState.touchCount == 1) { this.el.emit("onefingermove", detail); }
            if (currentState.touchCount == 2) { this.el.emit("twofingermove", detail); }
          }
          this.internalState.previousState = currentState;
        },
        getTouchState: function(event) {
          if (event.touches.length === 0) { return null; }
          const touchList = [];
          for (let i = 0; i < event.touches.length; i++) { touchList.push(event.touches[i]); }
          const touchMap = touchList.map(t => { return { x: t.clientX, y: t.clientY }; });
          
          if (event.touches.length === 1) {
            return { touchCount: 1, position: touchMap[0], spread: 0 };
          }
          const dx = touchMap[0].x - touchMap[1].x;
          const dy = touchMap[0].y - touchMap[1].y;
          return { touchCount: 2, position: { x: (touchMap[0].x + touchMap[1].x) / 2, y: (touchMap[0].y + touchMap[1].y) / 2 }, spread: Math.sqrt(dx * dx + dy * dy) };
        }
      });
    


      AFRAME.registerComponent('animar-ao-toque', {
        init: function () {
          const el = this.el;
          let estaAberto = false;

          el.addEventListener('click', function () {
             // Removemos o componente completamente para resetar o estado interno
             el.removeAttribute('animation-mixer');

             // Pequeno delay para garantir que o navegador processe a remoção
             setTimeout(() => {
                 if (!estaAberto) {
                     console.log("Abrindo...");
                     // Re-adiciona com velocidade normal
                     el.setAttribute('animation-mixer', {
                        loop: 'once',
                        timeScale: 1, 
                        clampWhenFinished: true 
                     });
                     estaAberto = true;
                 } else {
                     console.log("Fechando...");
                     // Re-adiciona com velocidade invertida
                     el.setAttribute('animation-mixer', {
                        loop: 'once',
                        timeScale: -1, 
                        clampWhenFinished: true 
                     });
                     estaAberto = false;
                 }
             }, 20); // 20ms de espera
          });
        }
      });
    

✅ Low Risk - https://swift-aquamarine-wlftjzo0u6-qy8ag2m587.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
3	43.152.26.58	Singapore	AS139341ACE
1	104.21.16.81	Singapore	AS139341
1	188.114.97.3	Singapore	AS139341
1	104.16.175.226	Singapore	AS139341
0	188.114.96.3	Singapore	AS139341
0	172.67.166.243	Singapore	AS139341
0	2606:4700:3036::6815:1051	Singapore	AS139341
0	2606:4700::6810:afe2	Singapore	AS139341
0	2606:4700:3033::ac43:a6f3	Singapore	AS139341
0	2a06:98c1:3121::3	Singapore	AS139341
6	13	-	-

Security Scan Report: swift-aquamarine-wlftjzo0u6-qy8ag2m587.edgeone.app

Summary

AI Security Verdict

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