technology software

English

You're looking at domain 'wordarena.pages.dev' on the developer-focused generic top-level domain (.dev), featuring subdomain 'wordarena'. The second-level label 'pages' is 5 characters long split between 2 vowels and three consonants. It segments into one word: pages. No strong language cues emerged from the frequency lists.

html/f0/60/f0607749-025a-4419-91e6-e97974f4a800.html.gz

c23a7c12b7f2d9edfb1de7fc22ecdd6b808f04005c4e7d9d9b75157a1a6e0056

viewport

Abuse Team

CloudFlare, Inc.

pages.dev

Cloudflare Abuse Contact

MNT-CLOUDFLARE

Cloudflare Technical Contact

CLOUDFLARENET-EU


        // Canvas setup
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d', { willReadFrequently: true });
        
        // Initialize canvas size
        canvas.width = 800;
        canvas.height = 600;
        ctx.fillStyle = 'white';
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        // State
        let currentTool = 'brush';
        let isDrawing = false;
        let lastX = 0;
        let lastY = 0;
        let currentColor = '#000000';
        let brushSize = 5;
        let opacity = 1;
        let history = [];
        let historyStep = -1;
        let startX, startY;

        // Save initial state
        saveState();

        // Color picker
        const colorPicker = document.getElementById('colorPicker');
        colorPicker.addEventListener('input', (e) => {
            currentColor = e.target.value;
            document.querySelector('.color-display').style.backgroundColor = currentColor;
        });

        function setColor(color) {
            currentColor = color;
            colorPicker.value = color;
            document.querySelector('.color-display').style.backgroundColor = color;
        }

        function updateBrushSize(value) {
            brushSize = parseInt(value);
            document.getElementById('sizeValue').textContent = value;
        }

        function updateOpacity(value) {
            opacity = value / 100;
            document.getElementById('opacityValue').textContent = value + '%';
        }

        function selectTool(tool) {
            currentTool = tool;
            document.querySelectorAll('.sidebar-tool').forEach(t => t.classList.remove('active'));
            document.querySelector(`[data-tool="${tool}"]`).classList.add('active');
            
            if (tool === 'eyedropper') {
                canvas.style.cursor = 'crosshair';
            } else if (tool === 'eraser') {
                canvas.style.cursor = 'crosshair';
            } else {
                canvas.style.cursor = 'crosshair';
            }
        }

        // Drawing functions
        canvas.addEventListener('mousedown', startDrawing);
        canvas.addEventListener('mousemove', draw);
        canvas.addEventListener('mouseup', stopDrawing);
        canvas.addEventListener('mouseout', stopDrawing);
        canvas.addEventListener('mousemove', updateCoords);

        function startDrawing(e) {
            const rect = canvas.getBoundingClientRect();
            const x = e.clientX - rect.left;
            const y = e.clientY - rect.top;
            
            if (currentTool === 'eyedropper') {
                pickColor(x, y);
                return;
            }
            
            if (currentTool === 'fill') {
                floodFill(Math.floor(x), Math.floor(y));
                saveState();
                return;
            }
            
            isDrawing = true;
            lastX = x;
            lastY = y;
            startX = x;
            startY = y;

            if (currentTool === 'brush' || currentTool === 'eraser') {
                ctx.beginPath();
                ctx.moveTo(x, y);
            }
        }

        function draw(e) {
            if (!isDrawing) return;
            
            const rect = canvas.getBoundingClientRect();
            const x = e.clientX - rect.left;
            const y = e.clientY - rect.top;

            ctx.lineCap = 'round';
            ctx.lineJoin = 'round';
            ctx.globalAlpha = opacity;

            if (currentTool === 'brush') {
                ctx.strokeStyle = currentColor;
                ctx.lineWidth = brushSize;
                ctx.lineTo(x, y);
                ctx.stroke();
                ctx.beginPath();
                ctx.moveTo(x, y);
            } else if (currentTool === 'eraser') {
                ctx.globalCompositeOperation = 'destination-out';
                ctx.lineWidth = brushSize;
                ctx.lineTo(x, y);
                ctx.stroke();
                ctx.beginPath();
                ctx.moveTo(x, y);
                ctx.globalCompositeOperation = 'source-over';
            } else if (currentTool === 'spray') {
                spray(x, y);
            }

            lastX = x;
            lastY = y;
        }

        function stopDrawing(e) {
            if (!isDrawing) return;
            
            const rect = canvas.getBoundingClientRect();
            const x = e.clientX - rect.left;
            const y = e.clientY - rect.top;

            if (currentTool === 'line') {
                drawLine(startX, startY, x, y);
            } else if (currentTool === 'rectangle') {
                drawRectangle(startX, startY, x, y);
            } else if (currentTool === 'circle') {
                drawCircle(startX, startY, x, y);
            }

            isDrawing = false;
            ctx.globalAlpha = 1;
            saveState();
        }

        function drawLine(x1, y1, x2, y2) {
            ctx.globalAlpha = opacity;
            ctx.strokeStyle = currentColor;
            ctx.lineWidth = brushSize;
            ctx.beginPath();
            ctx.moveTo(x1, y1);
            ctx.lineTo(x2, y2);
            ctx.stroke();
        }

        function drawRectangle(x1, y1, x2, y2) {
            ctx.globalAlpha = opacity;
            ctx.strokeStyle = currentColor;
            ctx.lineWidth = brushSize;
            ctx.strokeRect(x1, y1, x2 - x1, y2 - y1);
        }

        function drawCircle(x1, y1, x2, y2) {
            ctx.globalAlpha = opacity;
            ctx.strokeStyle = currentColor;
            ctx.lineWidth = brushSize;
            const radius = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
            ctx.beginPath();
            ctx.arc(x1, y1, radius, 0, Math.PI * 2);
            ctx.stroke();
        }

        function spray(x, y) {
            const density = 20;
            const radius = brushSize * 2;
            
            for (let i = 0; i < density; i++) {
                const offsetX = (Math.random() - 0.5) * radius;
                const offsetY = (Math.random() - 0.5) * radius;
                ctx.fillStyle = currentColor;
                ctx.fillRect(x + offsetX, y + offsetY, 1, 1);
            }
        }

        function pickColor(x, y) {
            const imageData = ctx.getImageData(x, y, 1, 1);
            const data = imageData.data;
            const hex = '#' + ((1 << 24) + (data[0] << 16) + (data[1] << 8) + data[2]).toString(16).slice(1);
            setColor(hex);
            selectTool('brush');
        }

        function floodFill(startX, startY) {
            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
            const targetColor = getColorAtPixel(imageData, startX, startY);
            const fillColor = hexToRgb(currentColor);
            
            if (colorsMatch(targetColor, fillColor)) return;
            
            const pixelsToCheck = [startX, startY];
            const width = canvas.width;
            const height = canvas.height;
            
            while (pixelsToCheck.length > 0) {
                const y = pixelsToCheck.pop();
                const x = pixelsToCheck.pop();
                
                const currentColor = getColorAtPixel(imageData, x, y);
                
                if (!colorsMatch(currentColor, targetColor)) continue;
                
                setColorAtPixel(imageData, x, y, fillColor);
                
                if (x > 0) pixelsToCheck.push(x - 1, y);
                if (x < width - 1) pixelsToCheck.push(x + 1, y);
                if (y > 0) pixelsToCheck.push(x, y - 1);
                if (y < height - 1) pixelsToCheck.push(x, y + 1);
            }
            
            ctx.putImageData(imageData, 0, 0);
        }

        function getColorAtPixel(imageData, x, y) {
            const index = (y * imageData.width + x) * 4;
            return {
                r: imageData.data[index],
                g: imageData.data[index + 1],
                b: imageData.data[index + 2],
                a: imageData.data[index + 3]
            };
        }

        function setColorAtPixel(imageData, x, y, color) {
            const index = (y * imageData.width + x) * 4;
            imageData.data[index] = color.r;
            imageData.data[index + 1] = color.g;
            imageData.data[index + 2] = color.b;
            imageData.data[index + 3] = Math.round(opacity * 255);
        }

        function colorsMatch(a, b) {
            return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
        }

        function hexToRgb(hex) {
            const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
            return result ? {
                r: parseInt(result[1], 16),
                g: parseInt(result[2], 16),
                b: parseInt(result[3], 16),
                a: 255
            } : null;
        }

        function updateCoords(e) {
            const rect = canvas.getBoundingClientRect();
            const x = Math.floor(e.clientX - rect.left);
            const y = Math.floor(e.clientY - rect.top);
            document.getElementById('coordsText').textContent = `X: ${x}, Y: ${y}`;
        }

        // History management
        function saveState() {
            historyStep++;
            if (historyStep < history.length) {
                history.length = historyStep;
            }
            history.push(canvas.toDataURL());
            if (history.length > 50) {
                history.shift();
                historyStep--;
            }
        }

        function undo() {
            if (historyStep > 0) {
                historyStep--;
                const img = new Image();
                img.src = history[historyStep];
                img.onload = () => {
                    ctx.clearRect(0, 0, canvas.width, canvas.height);
                    ctx.drawImage(img, 0, 0);
                };
            }
        }

        function redo() {
            if (historyStep < history.length - 1) {
                historyStep++;
                const img = new Image();
                img.src = history[historyStep];
                img.onload = () => {
                    ctx.clearRect(0, 0, canvas.width, canvas.height);
                    ctx.drawImage(img, 0, 0);
                };
            }
        }

        // Canvas operations
        function clearCanvas() {
            if (confirm('Are you sure you want to clear the canvas?')) {
                ctx.fillStyle = 'white';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
                saveState();
            }
        }

        function fillBackground() {
            ctx.fillStyle = currentColor;
            ctx.fillRect(0, 0, canvas.width, canvas.height);
            saveState();
        }

        function resizeCanvas() {
            const newWidth = parseInt(document.getElementById('canvasWidth').value);
            const newHeight = parseInt(document.getElementById('canvasHeight').value);
            
            const tempCanvas = document.createElement('canvas');
            const tempCtx = tempCanvas.getContext('2d');
            tempCanvas.width = canvas.width;
            tempCanvas.height = canvas.height;
            tempCtx.drawImage(canvas, 0, 0);
            
            canvas.width = newWidth;
            canvas.height = newHeight;
            ctx.fillStyle = 'white';
            ctx.fillRect(0, 0, canvas.width, canvas.height);
            ctx.drawImage(tempCanvas, 0, 0);
            
            saveState();
        }

        function newCanvas() {
            if (confirm('Create a new canvas? This will clear your current work.')) {
                canvas.width = 800;
                canvas.height = 600;
                document.getElementById('canvasWidth').value = 800;
                document.getElementById('canvasHeight').value = 600;
                ctx.fillStyle = 'white';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
                history = [];
                historyStep = -1;
                saveState();
            }
        }

        function saveCanvas() {
            const link = document.createElement('a');
            link.download = 'painting_' + Date.now() + '.png';
            link.href = canvas.toDataURL();
            link.click();
        }

        // Export functions
        function openExportModal() {
            document.getElementById('exportModal').classList.add('show');
        }

        function closeExportModal() {
            document.getElementById('exportModal').classList.remove('show');
        }

        function exportImage(format) {
            const link = document.createElement('a');
            link.download = `painting_${Date.now()}.${format}`;
            
            if (format === 'svg') {
                const svgData = `<svg xmlns="http://www.w3.org/2000/svg" width="${canvas.width}" height="${canvas.height}">
                    <image href="${canvas.toDataURL()}" width="${canvas.width}" height="${canvas.height}"/>
                </svg>`;
                const blob = new Blob([svgData], { type: 'image/svg+xml' });
                link.href = URL.createObjectURL(blob);
            } else {
                const mimeType = format === 'jpg' ? 'image/jpeg' : `image/${format}`;
                link.href = canvas.toDataURL(mimeType, 0.95);
            }
            
            link.click();
            closeExportModal();
        }

        // Keyboard shortcuts
        document.addEventListener('keydown', (e) => {
            if (e.ctrlKey || e.metaKey) {
                if (e.key === 'z') {
                    e.preventDefault();
                    undo();
                } else if (e.key === 'y') {
                    e.preventDefault();
                    redo();
                } else if (e.key === 's') {
                    e.preventDefault();
                    saveCanvas();
                }
            } else {
                switch(e.key.toLowerCase()) {
                    case 'b': selectTool('brush'); break;
                    case 'e': selectTool('eraser'); break;
                    case 'l': selectTool('line'); break;
                    case 'r': selectTool('rectangle'); break;
                    case 'c': selectTool('circle'); break;
                    case 's': selectTool('spray'); break;
                    case 'f': selectTool('fill'); break;
                    case 'i': selectTool('eyedropper'); break;
                }
            }
        });

        // Update status
        document.getElementById('statusText').textContent = 'Ready - Use the tools to start painting!';
    

Requests	IP Address	Location	AS Autonomous System
2	188.114.96.3	United States	AS13335Cloudflare, Inc.
2	1	-	-

Security Scan Report: wordarena.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 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