documentation technical

entertainment media

adult content

The domain name 'royal-indigo-qtxliwk11l-1z5mh5ebwf.edgeone.app' uses the application-focused generic top-level domain (.app), featuring subdomain 'royal-indigo-qtxliwk11l-1z5mh5ebwf'. Its registrable label 'edgeone' stretches across 7 characters split between 4 vowels and 3 consonants. Splitting it apart reveals 2 words: edge, one. Median word length is 3.5 characters. No strong language cues emerged from the frequency lists.

html/57/20/57206715-d764-49b3-a460-d62d82759421.html.gz

sha256=:m6pD72XSzu6+sviViRIehVkUdoMUg9LoFvah1/Q3Tss=:

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

176e894661aa9cdc9a5cba6c720044cbbf7b8bd80d1c9a142a7c24b1b6c50d15

9baa43ef65d2ceeebeb2f89589121e85591476831483d2e816f6a1d7f4374ecb

d4dfa4b7a39a76bd5b69255fac84478363a59ea6f598850af9910dbc756695ae

1945deae8ece553a414cad2243d9d7f6c7c77269a9360538ef9e1d3512fe4e01

width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=yes

viewport

html/57/20/57206715-d764-49b3-a460-d62d82759421_nodriver.html.gz

royal-indigo-qtxliwk11l-1z5mh5ebwf.edgeone.app

Prudence Malinki

MarkMonitor Inc.

edgeone.app

Abuse

Google LLC

GOOGLE


    const { createApp, ref, reactive, computed, watch, nextTick } = Vue;

    createApp({
      setup() {
        // ---------- data ----------
        const activeTab = ref('keys');
        const answerKeys = ref(JSON.parse(localStorage.getItem('mcq_keys')) || []);
        const scanHistory = ref(JSON.parse(localStorage.getItem('mcq_history')) || []);
        const letters = ['ক','খ','গ','ঘ','ঙ','চ','ছ','দ','ধ','ব'];

        // create modal
        const showCreateModal = ref(false);
        const newKey = ref({
          name: '',
          numQuestions: 30,
          choices: 4,
          correctAnswers: []
        });

        // scan panel
        const selectedKeyId = ref('');
        const video = ref(null);
        const canvasPreview = ref(null);
        const capturedImageData = ref(null);
        const cameraActive = ref(false);
        let stream = null;

        // roi
        const roiStart = ref({ x: 0, y: 0 });
        const roiEnd = ref({ x: 0, y: 0 });
        const showRoi = ref(false);
        const roiValid = ref(false);
        const roiRect = ref(null);
        let drawing = false;

        // result modal
        const showResultModal = ref(false);
        const currentResult = ref(null);

        // ---------- helpers ----------
        const genId = () => Date.now() + '-' + Math.random().toString(36).substr(2, 9);

        // save keys to localStorage
        watch(answerKeys, (val) => {
          localStorage.setItem('mcq_keys', JSON.stringify(val));
        }, { deep: true });

        watch(scanHistory, (val) => {
          localStorage.setItem('mcq_history', JSON.stringify(val));
        }, { deep: true });

        // initialize correct answers when numQuestions or choices change
        watch([() => newKey.value.numQuestions, () => newKey.value.choices], () => {
          const num = newKey.value.numQuestions || 30;
          const arr = Array(num).fill(0);
          newKey.value.correctAnswers = arr;
        }, { immediate: true });

        const setCorrect = (qIdx, optIdx) => {
          newKey.value.correctAnswers[qIdx] = optIdx;
        };

        const saveKey = () => {
          if (!newKey.value.name.trim()) { alert('নাম দিন'); return; }
          const key = {
            id: genId(),
            name: newKey.value.name,
            numQuestions: newKey.value.numQuestions,
            choices: newKey.value.choices,
            correctAnswers: [...newKey.value.correctAnswers]
          };
          answerKeys.value.push(key);
          showCreateModal.value = false;
          newKey.value = { name: '', numQuestions: 30, choices: 4, correctAnswers: [] };
        };

        // ---------- camera ----------
        const startCamera = async () => {
          try {
            if (stream) stream.getTracks().forEach(t => t.stop());
            stream = await navigator.mediaDevices.getUserMedia({ video: { facingMode: { ideal: 'environment' } } });
            if (video.value) {
              video.value.srcObject = stream;
              cameraActive.value = true;
            }
          } catch (err) {
            alert('ক্যামেরা অ্যাক্সেস দেওয়া হয়নি: ' + err.message);
          }
        };

        const captureImage = () => {
          if (!cameraActive.value || !selectedKeyId.value) {
            alert('প্রথমে ক্যামেরা চালু করুন এবং একটি চাবি নির্বাচন করুন');
            return;
          }
          const v = video.value;
          if (!v || !v.videoWidth) {
            alert('ভিডিও প্রস্তুত নয়');
            return;
          }
          const canvas = canvasPreview.value;
          canvas.width = v.videoWidth;
          canvas.height = v.videoHeight;
          const ctx = canvas.getContext('2d');
          ctx.drawImage(v, 0, 0, canvas.width, canvas.height);
          capturedImageData.value = ctx.getImageData(0, 0, canvas.width, canvas.height);
          // stop camera
          if (stream) { stream.getTracks().forEach(t => t.stop()); stream = null; cameraActive.value = false; }
          // reset roi
          showRoi.value = false;
          roiValid.value = false;
          // attach events after next render
          nextTick(() => {
            attachRoiEvents();
          });
        };

        // ROI drag handling
        const attachRoiEvents = () => {
          const canvas = canvasPreview.value;
          if (!canvas) return;
          const rectDiv = roiRect.value;

          const handleStart = (e) => {
            e.preventDefault();
            const rect = canvas.getBoundingClientRect();
            const scaleX = canvas.width / rect.width;
            const scaleY = canvas.height / rect.height;
            let clientX, clientY;
            if (e.touches) {
              clientX = e.touches[0].clientX;
              clientY = e.touches[0].clientY;
            } else {
              clientX = e.clientX;
              clientY = e.clientY;
            }
            roiStart.value.x = (clientX - rect.left) * scaleX;
            roiStart.value.y = (clientY - rect.top) * scaleY;
            roiEnd.value.x = roiStart.value.x;
            roiEnd.value.y = roiStart.value.y;
            drawing = true;
            showRoi.value = true;
            roiValid.value = false;
          };

          const handleMove = (e) => {
            if (!drawing) return;
            e.preventDefault();
            const rect = canvas.getBoundingClientRect();
            const scaleX = canvas.width / rect.width;
            const scaleY = canvas.height / rect.height;
            let clientX, clientY;
            if (e.touches) {
              clientX = e.touches[0].clientX;
              clientY = e.touches[0].clientY;
            } else {
              clientX = e.clientX;
              clientY = e.clientY;
            }
            let x = (clientX - rect.left) * scaleX;
            let y = (clientY - rect.top) * scaleY;
            x = Math.min(canvas.width, Math.max(0, x));
            y = Math.min(canvas.height, Math.max(0, y));
            roiEnd.value.x = x;
            roiEnd.value.y = y;
          };

          const handleEnd = () => {
            if (!drawing) return;
            drawing = false;
            // validate area
            const w = Math.abs(roiEnd.value.x - roiStart.value.x);
            const h = Math.abs(roiEnd.value.y - roiStart.value.y);
            if (w > 20 && h > 20) roiValid.value = true;
            else showRoi.value = false;
          };

          canvas.addEventListener('mousedown', handleStart);
          canvas.addEventListener('mousemove', handleMove);
          canvas.addEventListener('mouseup', handleEnd);
          canvas.addEventListener('mouseleave', handleEnd);
          canvas.addEventListener('touchstart', handleStart, { passive: false });
          canvas.addEventListener('touchmove', handleMove, { passive: false });
          canvas.addEventListener('touchend', handleEnd);
          canvas.addEventListener('touchcancel', handleEnd);
        };

        const roiStyle = computed(() => {
          if (!showRoi.value) return { display: 'none' };
          const canvas = canvasPreview.value;
          if (!canvas) return {};
          const rect = canvas.getBoundingClientRect();
          const left = Math.min(roiStart.value.x, roiEnd.value.x);
          const top = Math.min(roiStart.value.y, roiEnd.value.y);
          const width = Math.abs(roiEnd.value.x - roiStart.value.x);
          const height = Math.abs(roiEnd.value.y - roiStart.value.y);
          const scaleX = rect.width / canvas.width;
          const scaleY = rect.height / canvas.height;
          return {
            left: (left * scaleX) + 'px',
            top: (top * scaleY) + 'px',
            width: (width * scaleX) + 'px',
            height: (height * scaleY) + 'px',
            display: 'block'
          };
        });

        // ---------- auto detect grid ----------
        const autoDetectGrid = () => {
          if (!capturedImageData.value) return;
          const imgData = capturedImageData.value;
          const w = imgData.width;
          const h = imgData.height;
          const data = imgData.data;

          // convert to grayscale and compute horizontal and vertical projections of dark pixels (bubbles)
          const gray = new Uint8Array(w * h);
          for (let i = 0; i < w * h; i++) {
            const r = data[i*4];
            const g = data[i*4+1];
            const b = data[i*4+2];
            gray[i] = 0.299 * r + 0.587 * g + 0.114 * b;
          }

          // threshold (assuming bubbles are dark)
          const threshold = 180;
          const hProj = new Array(h).fill(0);
          const vProj = new Array(w).fill(0);
          for (let y = 0; y < h; y++) {
            for (let x = 0; x < w; x++) {
              if (gray[y * w + x] < threshold) {
                hProj[y]++;
                vProj[x]++;
              }
            }
          }

          // find top and bottom of answer area: look for consecutive rows with high projection
          const minRowProj = 5; // minimum dark pixels per row to be considered part of grid
          let top = 0, bottom = h-1;
          // find top
          for (let y = 0; y < h; y++) {
            if (hProj[y] > minRowProj) { top = y; break; }
          }
          // find bottom
          for (let y = h-1; y >= 0; y--) {
            if (hProj[y] > minRowProj) { bottom = y; break; }
          }
          // similarly left/right
          let left = 0, right = w-1;
          for (let x = 0; x < w; x++) {
            if (vProj[x] > minRowProj) { left = x; break; }
          }
          for (let x = w-1; x >= 0; x--) {
            if (vProj[x] > minRowProj) { right = x; break; }
          }

          // add some margin
          const margin = 5;
          left = Math.max(0, left - margin);
          top = Math.max(0, top - margin);
          right = Math.min(w-1, right + margin);
          bottom = Math.min(h-1, bottom + margin);

          roiStart.value = { x: left, y: top };
          roiEnd.value = { x: right, y: bottom };
          showRoi.value = true;
          roiValid.value = true;
        };

        // ---------- scan ROI and detect bubbles ----------
        const scanRoi = () => {
          if (!roiValid.value || !selectedKeyId.value) return;
          const key = answerKeys.value.find(k => k.id === selectedKeyId.value);
          if (!key) return;
          const canvas = canvasPreview.value;
          const left = Math.min(roiStart.value.x, roiEnd.value.x);
          const top = Math.min(roiStart.value.y, roiEnd.value.y);
          const width = Math.abs(roiEnd.value.x - roiStart.value.x);
          const height = Math.abs(roiEnd.value.y - roiStart.value.y);
          const fullData = capturedImageData.value;

          // create cropped canvas
          const cropCanvas = document.createElement('canvas');
          cropCanvas.width = width;
          cropCanvas.height = height;
          const ctx = cropCanvas.getContext('2d');
          ctx.putImageData(fullData, 0, 0, left, top, width, height);
          const roiData = ctx.getImageData(0, 0, width, height);

          const numQ = key.numQuestions;
          const choices = key.choices;
          const cellH = height / numQ;
          const cellW = width / choices;
          const answers = [];

          for (let row = 0; row < numQ; row++) {
            let bestOption = 0;
            let minBrightness = 255;
            for (let col = 0; col < choices; col++) {
              const centerX = Math.floor(col * cellW + cellW * 0.5);
              const centerY = Math.floor(row * cellH + cellH * 0.5);
              const sampleSize = 8;
              let total = 0, count = 0;
              for (let dy = -sampleSize/2; dy < sampleSize/2; dy++) {
                for (let dx = -sampleSize/2; dx < sampleSize/2; dx++) {
                  const px = Math.floor(centerX + dx);
                  const py = Math.floor(centerY + dy);
                  if (px >= 0 && px < width && py >= 0 && py < height) {
                    const idx = (py * width + px) * 4;
                    const r = roiData.data[idx];
                    const g = roiData.data[idx+1];
                    const b = roiData.data[idx+2];
                    const brightness = 0.299 * r + 0.587 * g + 0.114 * b;
                    total += brightness;
                    count++;
                  }
                }
              }
              if (count === 0) continue;
              const avg = total / count;
              if (avg < minBrightness) {
                minBrightness = avg;
                bestOption = col;
              }
            }
            answers.push(bestOption);
          }

          const correct = key.correctAnswers;
          let score = 0;
          correct.forEach((c, idx) => { if (c === answers[idx]) score++; });

          const result = {
            id: genId(),
            keyId: key.id,
            keyName: key.name,
            timestamp: new Date().toLocaleString('bn-BD'),
            studentAnswers: answers,
            correctAnswers: correct,
            score: score,
            total: numQ,
            choices: choices
          };
          scanHistory.value.push(result);
          currentResult.value = result;
          showResultModal.value = true;
        };

        const showResult = (hist) => {
          currentResult.value = hist;
          showResultModal.value = true;
        };

        const reversedHistory = computed(() => {
          return [...scanHistory.value].reverse();
        });

        return {
          activeTab,
          answerKeys,
          scanHistory,
          letters,
          showCreateModal,
          newKey,
          setCorrect,
          saveKey,
          selectedKeyId,
          video,
          canvasPreview,
          capturedImageData,
          cameraActive,
          startCamera,
          captureImage,
          roiStart,
          roiEnd,
          showRoi,
          roiValid,
          roiRect,
          roiStyle,
          scanRoi,
          autoDetectGrid,
          showResultModal,
          currentResult,
          showResult,
          reversedHistory
        };
      }
    }).mount('#app');
  

Vue.js

Tailwind CSS

Unpkg

✅ Low Risk - https://royal-indigo-qtxliwk11l-1z5mh5ebwf.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
13	43.152.26.58	Singapore	AS139341ACE
13	1	-	-

Security Scan Report: royal-indigo-qtxliwk11l-1z5mh5ebwf.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

Detected Technologies3

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