entertainment media

news media journalism

adult content

healthcare medical

cryptocurrency blockchain

English

Domain 'sudoku-7rd.pages.dev' uses the developer-focused generic top-level domain (.dev) and includes subdomain 'sudoku-7rd'. The core label 'pages' covers 5 characters containing 2 vowels alongside 3 consonants. Word splitting yields one word: pages. No strong language cues emerged from the frequency lists.

html/b0/f6/b0f62a07-34ac-43f0-baca-e47dd8309a4c.html.gz

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

176e894661aa9cdc9a5cba6c720044cbbf7b8bd80d1c9a142a7c24b1b6c50d15

e87e550794322e574a1fda0c1549a3c70dae5a93d9113417a429016838eab8cb

07f6fdb3c9d243a9e85231d9469b6aad25a89b376dc8bc63c3dc5561f606aef1

be04c54896e52d667c13fb5cca11a44de6e46f1e85926b8817bd9f5d75eb006b

viewport

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


    // --- UI Elements ---
    const boardElement = document.getElementById('sudoku-board');
    const resetButton = document.getElementById('reset-button');
    const undoButton = document.getElementById('undo-button');
    const redoButton = document.getElementById('redo-button');
    const copyPngButton = document.getElementById('copy-png-button');
    const solveButton = document.getElementById('solve-button');
    const solverStatus = document.getElementById('solver-status');
    const speedSlider = document.getElementById('speed-slider');

    // --- State Management ---
    let history = [];
    let historyIndex = -1;
    let isSolving = false;
    let animationDelay = 25; // Default delay

    // --- Core UI Functions ---
    function initializeBoard() {
        boardElement.innerHTML = ''; 
        for (let i = 0; i < 81; i++) {
            const cell = document.createElement('div');
            // Removed default background color, it will be added conditionally
            cell.classList.add('cell', 'w-10', 'h-10', 'sm:w-12', 'sm:h-12', 'md:w-14', 'md:h-14', 'border', 'border-slate-300', 'relative');
            const row = Math.floor(i / 9);
            const col = i % 9;
            cell.dataset.row = row;
            cell.dataset.col = col;

            // Add shaded background to alternating boxes
            const boxIndex = Math.floor(row / 3) * 3 + Math.floor(col / 3);
            if ([0, 2, 4, 6, 8].includes(boxIndex)) {
                cell.classList.add('shaded-box');
            } else {
                cell.classList.add('bg-white'); // Apply white to non-shaded boxes
            }

            const mainNumber = document.createElement('div');
            mainNumber.classList.add('main-number', 'text-2xl', 'md:text-3xl', 'font-bold', 'text-slate-700');
            const pencilMarksContainer = document.createElement('div');
            pencilMarksContainer.classList.add('pencil-marks', 'grid', 'grid-cols-3', 'w-full', 'h-full', 'absolute', 'top-0', 'left-0');
            for (let n = 1; n <= 9; n++) {
                const pencilMark = document.createElement('div');
                pencilMark.classList.add('pencil-mark', 'text-xs', 'text-slate-400', 'flex', 'justify-center', 'items-center', 'rounded-sm');
                pencilMark.textContent = n;
                pencilMark.dataset.number = n;
                pencilMark.addEventListener('click', handlePencilClick);
                pencilMarksContainer.appendChild(pencilMark);
            }
            cell.appendChild(mainNumber);
            cell.appendChild(pencilMarksContainer);
            cell.addEventListener('click', handleCellClick);
            boardElement.appendChild(cell);
        }
        history = [];
        historyIndex = -1;
        saveState();
        solverStatus.textContent = ''; // Clear solver status message
        handleSpeedChange(); // Set initial speed
    }

    function saveState() {
        const currentState = Array.from(document.querySelectorAll('.cell .main-number')).map(el => el.textContent);
        history = history.slice(0, historyIndex + 1);
        history.push(currentState);
        historyIndex++;
        updateUndoRedoButtons();
    }

    function loadState(state) {
        document.querySelectorAll('.cell').forEach((cell, index) => {
            const number = state[index];
            const mainNumberEl = cell.querySelector('.main-number');
            const pencilMarksEl = cell.querySelector('.pencil-marks');
            cell.classList.remove('pre-filled');
            if (number) {
                cell.classList.add('filled');
                mainNumberEl.textContent = number;
                pencilMarksEl.classList.add('hidden');
            } else {
                cell.classList.remove('filled');
                mainNumberEl.textContent = '';
                pencilMarksEl.classList.remove('hidden');
            }
        });
        updateAllPencilMarks();
        updateUndoRedoButtons();
    }

    function handlePencilClick(event) {
        if (isSolving) return;
        event.stopPropagation();
        const pencilMark = event.currentTarget;
        const cell = pencilMark.closest('.cell');
        if (cell.classList.contains('filled')) return;
        cell.querySelector('.main-number').textContent = pencilMark.dataset.number;
        cell.classList.add('filled');
        cell.querySelector('.pencil-marks').classList.add('hidden');
        updateAllPencilMarks();
        saveState();
    }

    function handleCellClick(event) {
        if (isSolving) return;
        const cell = event.currentTarget;
        if (!cell.classList.contains('filled')) return;
        cell.classList.remove('filled');
        cell.querySelector('.main-number').textContent = '';
        cell.querySelector('.pencil-marks').classList.remove('hidden');
        updateAllPencilMarks();
        saveState();
    }

    function updateAllPencilMarks() {
        const filledCells = [];
        document.querySelectorAll('.cell').forEach(c => {
            const mainNumber = c.querySelector('.main-number').textContent;
            if (mainNumber) {
                 filledCells.push({
                    row: parseInt(c.dataset.row),
                    col: parseInt(c.dataset.col),
                    num: mainNumber
                });
            }
        });
        document.querySelectorAll('.cell').forEach(cell => {
            const isFilled = cell.querySelector('.main-number').textContent !== '';
            cell.querySelector('.pencil-marks').classList.toggle('hidden', isFilled);
            if (!isFilled) {
                const r = parseInt(cell.dataset.row);
                const c = parseInt(cell.dataset.col);
                for (let n = 1; n <= 9; n++) {
                    const pencilMark = cell.querySelector(`.pencil-mark[data-number='${n}']`);
                    pencilMark.style.visibility = isConflict(r, c, n.toString(), filledCells) ? 'hidden' : 'visible';
                }
            }
        });
    }

    function isConflict(row, col, number, filledCells) {
        const boxStartRow = Math.floor(row / 3) * 3;
        const boxStartCol = Math.floor(col / 3) * 3;
        return filledCells.some(filled => filled.num === number && (
            filled.row === row ||
            filled.col === col ||
            (filled.row >= boxStartRow && filled.row < boxStartRow + 3 && filled.col >= boxStartCol && filled.col < boxStartCol + 3)
        ));
    }

    function setControlsDisabled(disabled) {
        isSolving = disabled;
        [solveButton, undoButton, redoButton, copyPngButton, resetButton, speedSlider].forEach(el => el.disabled = disabled);
    }
    
    function handleSpeedChange() {
        // Higher slider value means faster speed (lower delay)
        animationDelay = 101 - parseInt(speedSlider.value);
    }

    // --- Undo/Redo and Copy Functions ---
    function updateUndoRedoButtons() {
        undoButton.disabled = historyIndex <= 0;
        redoButton.disabled = historyIndex >= history.length - 1;
    }
    function undo() { if (historyIndex > 0) { historyIndex--; loadState(history[historyIndex]); } }
    function redo() { if (historyIndex < history.length - 1) { historyIndex++; loadState(history[historyIndex]); } }
    
    async function copyBoardAsPng() {
      try {
        const board = boardElement;
        const scale = Math.max(1, Math.floor(window.devicePixelRatio || 1));

        // 🔹 Apply export-time nudge
        document.documentElement.classList.add('exporting');

        const canvas = await html2canvas(board, {
          backgroundColor: '#ffffff',
          scale,
          useCORS: true,
          logging: false
        });

        // 🔹 Remove nudge immediately after snapshot
        document.documentElement.classList.remove('exporting');

        canvas.toBlob(async (blob) => {
          if (!blob) throw new Error('PNG creation failed');
          if (navigator.clipboard && window.ClipboardItem) {
            await navigator.clipboard.write([new ClipboardItem({ 'image/png': blob })]);
            solverStatus.textContent = 'PNG copied to clipboard!';
          } else {
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = 'sudoku.png';
            a.click();
            URL.revokeObjectURL(url);
            solverStatus.textContent = 'PNG downloaded.';
          }
        }, 'image/png');
      } catch (err) {
        console.error(err);
        solverStatus.textContent = 'Error copying PNG.';
        // make sure class is removed on error as well
        document.documentElement.classList.remove('exporting');
      }
    }

    // --- DANCING LINKS (DLX) SOLVER ---
    const COLS = 324;
    const ROWS = 729;
    let head, columns, solution, animationSteps;

    function createDLXMatrix() {
        head = { L: null, R: null, U: null, D: null, C: null, S: -1, N: 'head' };
        head.L = head.R = head;
        columns = [];
        for (let i = 0; i < COLS; i++) {
            const C = { L: head.L, R: head, U: null, D: null, C: null, S: 0, N: i };
            C.U = C.D = C;
            head.L.R = C;
            head.L = C;
            columns.push(C);
        }
        for (let r = 0; r < 9; r++) {
            for (let c = 0; c < 9; c++) {
                for (let n = 0; n < 9; n++) {
                    const row = [];
                    const box = Math.floor(r / 3) * 3 + Math.floor(c / 3);
                    row.push(r * 9 + c);
                    row.push(81 + r * 9 + n);
                    row.push(162 + c * 9 + n);
                    row.push(243 + box * 9 + n);
                    let firstNode = null;
                    for (const colIdx of row) {
                        const C = columns[colIdx];
                        const newNode = { L: null, R: null, U: C.U, D: C, C: C, row: r, col: c, num: n + 1 };
                        C.U.D = newNode;
                        C.U = newNode;
                        C.S++;
                        if (firstNode) {
                            newNode.L = firstNode.L;
                            newNode.R = firstNode;
                            firstNode.L.R = newNode;
                            firstNode.L = newNode;
                        } else {
                            firstNode = newNode;
                            firstNode.L = firstNode.R = firstNode;
                        }
                    }
                }
            }
        }
    }

    function cover(C) {
        C.R.L = C.L;
        C.L.R = C.R;
        for (let i = C.D; i !== C; i = i.D) {
            for (let j = i.R; j !== i; j = j.R) {
                j.D.U = j.U;
                j.U.D = j.D;
                j.C.S--;
            }
        }
    }

    function uncover(C) {
        for (let i = C.U; i !== C; i = i.U) {
            for (let j = i.L; j !== i; j = j.L) {
                j.C.S++;
                j.D.U = j;
                j.U.D = j;
            }
        }
        C.R.L = C;
        C.L.R = C;
    }

    function search(k) {
        if (head.R === head) return true;
        let C = head.R;
        for(let t = head.R; t !== head; t = t.R) {
            if (t.S < C.S) C = t;
        }
        cover(C);
        for (let r = C.D; r !== C; r = r.D) {
            solution.push(r);
            animationSteps.push({ type: 'try', row: r.row, col: r.col, num: r.num });
            for (let j = r.R; j !== r; j = j.R) cover(j.C);
            if (search(k + 1)) return true;
            for (let j = r.L; j !== r; j = j.L) uncover(j.C);
            solution.pop();
            animationSteps.push({ type: 'backtrack', row: r.row, col: r.col });
        }
        uncover(C);
        return false;
    }

    async function solveAndAnimate() {
        setControlsDisabled(true);
        solverStatus.textContent = 'Setting up solver...';
        document.querySelectorAll('.cell').forEach(c => {
            c.classList.remove('pre-filled', 'filled');
            c.querySelector('.pencil-marks').classList.remove('hidden');
        });
        const initialBoard = [];
        document.querySelectorAll('.cell .main-number').forEach((el, i) => {
            if (el.textContent) {
                initialBoard.push({
                    row: Math.floor(i/9), col: i%9, num: parseInt(el.textContent)
                });
                el.parentElement.classList.add('pre-filled');
            }
        });
        updateAllPencilMarks();
        await new Promise(resolve => setTimeout(resolve, 100));
        solverStatus.textContent = 'Building constraints...';
        createDLXMatrix();
        for (const {row, col, num} of initialBoard) {
             let found = false;
             for(let C = columns[row * 9 + col].D; C !== columns[row * 9 + col] && !found; C = C.D) {
                 if(C.num === num) {
                     cover(C.C);
                     for(let j = C.R; j !== C; j = j.R) cover(j.C);
                     found = true;
                 }
             }
        }
        solution = [];
        animationSteps = [];
        solverStatus.textContent = 'Solving with Dancing Links...';
        const foundSolution = search(0);
        if (foundSolution) {
            animateSolution();
        } else {
            solverStatus.textContent = 'No solution found for this board.';
            setControlsDisabled(false);
        }
    }

    function animateSolution() {
        let step = 0;
        const delay = animationDelay; // Use the variable delay
        function nextStep() {
            if (step >= animationSteps.length) {
                solverStatus.textContent = 'Solution found!';
                for (const node of solution) {
                    const cell = document.querySelector(`.cell[data-row='${node.row}'][data-col='${node.col}']`);
                    cell.querySelector('.main-number').textContent = node.num;
                }
                updateAllPencilMarks();
                setControlsDisabled(false);
                return;
            }
            const { type, row, col, num } = animationSteps[step];
            const cell = document.querySelector(`.cell[data-row='${row}'][data-col='${col}']`);
            if (type === 'try') {
                cell.querySelector('.main-number').textContent = num;
                cell.classList.add('solving-try');
            } else {
                cell.querySelector('.main-number').textContent = '';
                cell.classList.add('solving-backtrack');
            }
            updateAllPencilMarks();
            setTimeout(() => {
                cell.classList.remove('solving-try', 'solving-backtrack');
            }, delay);
            step++;
            setTimeout(nextStep, delay);
        }
        nextStep();
    }

    // --- Event Listeners ---
    resetButton.addEventListener('click', initializeBoard);
    undoButton.addEventListener('click', undo);
    redoButton.addEventListener('click', redo);
    copyPngButton.addEventListener('click', copyBoardAsPng);
    solveButton.addEventListener('click', solveAndAnimate);
    speedSlider.addEventListener('input', handleSpeedChange);

    initializeBoard();


Requests	IP Address	Location	AS Autonomous System
5	104.26.2.143	United States	AS13335Cloudflare, Inc.
1	104.17.25.14	United States	AS13335
1	192.178.183.94	United States	Unknown
1	142.251.13.95	United States	Unknown
1	188.114.97.3	United States	AS13335Cloudflare, Inc.
9	5	-	-

Security Scan Report: sudoku-7rd.pages.dev

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

Detected Technologies5

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