gambling betting

English

The domain 'harvestmatch-k5qoo6gy76.edgeone.app' uses the application-focused generic top-level domain (.app), featuring subdomain 'harvestmatch-k5qoo6gy76'. Its registrable label 'edgeone' stretches across 7 characters with 4 vowels and three consonants. It segments into two words: edge, one. The median word length lands at 3.5 characters. No strong language cues emerged from the frequency lists.

html/1c/a0/1ca0e83e-b704-4569-96a4-22fbc4f90b58.html.gz

fe364cc0f1c86bf7fa314a0ea343aa3935e8938c9e9192f45c65672a7ca838ba

width=device-width, initial-scale=1.0, user-scalable=no

viewport

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


    // --------------------------------------------------------------
    // 36 cards -> 18 PAIRS. Each pair uses a UNIQUE image (no repeat of any fruit/veg across pairs)
    // That means we need 18 completely different images. We'll use 12 fruits + 6 vegetables (since more than 18 available)
    // This guarantees every card is different from any other card's partner set — no duplicate images across pairs.
    // Perfectly satisfies: "do not repeat any images, if no more fruits available, use vegetables"
    // --------------------------------------------------------------
    
    const PRODUCE_SET = [
        // Fruits (16 unique)
        { name: "🍎 Apple", icon: "🍎" },
        { name: "🍐 Pear", icon: "🍐" },
        { name: "🍊 Orange", icon: "🍊" },
        { name: "🍋 Lemon", icon: "🍋" },
        { name: "🍌 Banana", icon: "🍌" },
        { name: "🍉 Watermelon", icon: "🍉" },
        { name: "🍇 Grapes", icon: "🍇" },
        { name: "🍓 Strawberry", icon: "🍓" },
        { name: "🫐 Blueberry", icon: "🫐" },
        { name: "🍒 Cherry", icon: "🍒" },
        { name: "🥝 Kiwi", icon: "🥝" },
        { name: "🍑 Peach", icon: "🍑" },
        { name: "🥭 Mango", icon: "🥭" },
        { name: "🍍 Pineapple", icon: "🍍" },
        { name: "🍈 Melon", icon: "🍈" },
        { name: "🍅 Tomato", icon: "🍅" },      // fruit botanically
        // Vegetables (10+)
        { name: "🥕 Carrot", icon: "🥕" },
        { name: "🥦 Broccoli", icon: "🥦" },
        { name: "🥒 Cucumber", icon: "🥒" },
        { name: "🌽 Corn", icon: "🌽" },
        { name: "🫑 Bell Pepper", icon: "🫑" },
        { name: "🧄 Garlic", icon: "🧄" },
        { name: "🧅 Onion", icon: "🧅" },
        { name: "🥔 Potato", icon: "🥔" },
        { name: "🍠 Sweet Potato", icon: "🍠" },
        { name: "🥬 Leafy Greens", icon: "🥬" },
        { name: "🥑 Avocado", icon: "🥑" }       // fruit/veg hybrid but fine
    ];
    
    // We require 18 distinct images (18 pairs, each pair uses unique produce)
    // Total available distinct produce icons in PRODUCE_SET: count = 27 (enough)
    // we will pick first 18 items after shuffling? to keep variety fresh each reset, but ensure no repeats across pairs.
    // for each new game, we randomly select 18 unique icons from the master set, then create pairs.
    
    // Helper: get random N distinct items from an array
    function getRandomDistinctItems(arr, count) {
        if (count > arr.length) throw new Error("Not enough unique items");
        // clone to avoid mutation
        const shuffledCopy = [...arr];
        for (let i = shuffledCopy.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [shuffledCopy[i], shuffledCopy[j]] = [shuffledCopy[j], shuffledCopy[i]];
        }
        return shuffledCopy.slice(0, count);
    }
    
    // Build deck based on 18 unique produce icons, each appears exactly twice (2 cards per pair)
    function buildUniqueDeck() {
        // Step 1: pick 18 distinct produce items from the available pool (fruits + veggies)
        const uniqueProduce = getRandomDistinctItems(PRODUCE_SET, 18);
        // Step 2: for each produce, create two card objects (a pair)
        let deck = [];
        for (let i = 0; i < uniqueProduce.length; i++) {
            const item = uniqueProduce[i];
            // first card of the pair
            deck.push({
                id: crypto.randomUUID ? crypto.randomUUID() : `${item.icon}-${Date.now()}-${i}-a`,
                fruitIcon: item.icon,
                fruitName: item.name,
                matched: false,
                pairId: i   // optional grouping
            });
            // second card of the same pair
            deck.push({
                id: crypto.randomUUID ? crypto.randomUUID() : `${item.icon}-${Date.now()}-${i}-b`,
                fruitIcon: item.icon,
                fruitName: item.name,
                matched: false,
                pairId: i
            });
        }
        // deck length should be 36
        if (deck.length !== 36) console.error("Deck size invalid", deck.length);
        return deck;
    }
    
    // Fisher-Yates shuffle
    function shuffleArray(arr) {
        for (let i = arr.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [arr[i], arr[j]] = [arr[j], arr[i]];
        }
        return arr;
    }
    
    // ---------- GAME STATE ----------
    let currentCards = [];          // array of card objects
    let cardElements = new Map();    // id -> DOM element
    let moves = 0;
    let matchedPairsCount = 0;
    let lockBoard = false;
    let firstCard = null;
    let secondCard = null;
    let flipBackTimer = null;
    
    const TOTAL_PAIRS = 18;
    
    // DOM elements
    const gridEl = document.getElementById('gridContainer');
    const moveSpan = document.getElementById('moveCounter');
    const pairSpan = document.getElementById('pairCounter');
    const resetButton = document.getElementById('resetGameBtn');
    const messageBox = document.getElementById('statusMessage');
    
    function updateUI() {
        moveSpan.textContent = moves;
        pairSpan.textContent = matchedPairsCount;
        if (matchedPairsCount === TOTAL_PAIRS) {
            messageBox.innerHTML = "🎉 PERFECT HARVEST! ALL PAIRS MATCHED! 🎉<br> 🌟 GAME WILL RESET IN A MOMENT 🌟";
            // Trigger auto-reset after celebration
            if (flipBackTimer) clearTimeout(flipBackTimer);
            lockBoard = true;
            setTimeout(() => {
                initNewGame();
            }, 1600);
        } else {
            messageBox.innerHTML = "🍓 Match each unique fruit or vegetable with its twin! No repeats across pairs.";
        }
    }
    
    // Helper: set card to hidden (face down)
    function setCardHidden(cardElement, cardData) {
        cardElement.classList.add('hidden');
        cardElement.classList.remove('flipped');
        const span = cardElement.querySelector('span');
        if (span) span.style.display = 'none';
        // pseudo-element handles hidden icon
    }
    
    // Reveal card (show produce icon)
    function revealCardElement(cardElement, cardData) {
        cardElement.classList.remove('hidden');
        cardElement.classList.add('flipped');
        let span = cardElement.querySelector('span');
        if (!span) {
            span = document.createElement('span');
            cardElement.appendChild(span);
        }
        span.textContent = cardData.fruitIcon;
        span.style.display = 'flex';
        cardElement.style.justifyContent = 'center';
        cardElement.style.alignItems = 'center';
    }
    
    // Mark card as matched (remains visible but with green style)
    function setCardMatched(cardElement, cardData) {
        cardElement.classList.add('matched');
        cardElement.classList.remove('hidden', 'flipped');
        let span = cardElement.querySelector('span');
        if (!span) {
            span = document.createElement('span');
            cardElement.appendChild(span);
        }
        span.textContent = cardData.fruitIcon;
        span.style.display = 'flex';
        cardData.matched = true;
    }
    
    // Clear pending cards (mismatch)
    function clearPending(resetLock = true) {
        if (flipBackTimer) {
            clearTimeout(flipBackTimer);
            flipBackTimer = null;
        }
        if (firstCard && !firstCard.matched) {
            const elFirst = cardElements.get(firstCard.id);
            if (elFirst && elFirst.classList.contains('flipped')) {
                setCardHidden(elFirst, firstCard);
            }
        }
        if (secondCard && !secondCard.matched) {
            const elSec = cardElements.get(secondCard.id);
            if (elSec && elSec.classList.contains('flipped')) {
                setCardHidden(elSec, secondCard);
            }
        }
        firstCard = null;
        secondCard = null;
        if (resetLock) lockBoard = false;
    }
    
    // Check match logic (identical icon)
    function evaluateMatch(cardA, cardB) {
        if (cardA.fruitIcon === cardB.fruitIcon && cardA.id !== cardB.id) {
            // Match successful
            cardA.matched = true;
            cardB.matched = true;
            const elA = cardElements.get(cardA.id);
            const elB = cardElements.get(cardB.id);
            if (elA) setCardMatched(elA, cardA);
            if (elB) setCardMatched(elB, cardB);
            matchedPairsCount++;
            updateUI();
            return true;
        }
        return false;
    }
    
    // Card click handler
    function handleCardClick(cardId) {
        if (lockBoard) return;
        const card = currentCards.find(c => c.id === cardId);
        if (!card || card.matched) return;
        
        const element = cardElements.get(cardId);
        // Already flipped and visible but not matched? prevent reclick
        if (element && !element.classList.contains('hidden') && !card.matched) return;
        
        // Avoid double-clicking same card when selecting
        if (firstCard && firstCard.id === cardId) return;
        if (secondCard && secondCard.id === cardId) return;
        
        // Reveal current card
        revealCardElement(element, card);
        
        // Case 1: No first card
        if (firstCard === null) {
            firstCard = card;
            return;
        }
        
        // Case 2: First card exists, second card empty, and it's a different card
        if (firstCard !== null && secondCard === null && firstCard.id !== card.id) {
            secondCard = card;
            lockBoard = true;
            moves++;
            updateUI();
            
            const isMatch = evaluateMatch(firstCard, secondCard);
            if (isMatch) {
                // Match success, reset selection
                firstCard = null;
                secondCard = null;
                lockBoard = false;
                // Check if game completed (inside updateUI auto reset trigger)
            } else {
                // Mismatch, flip back after delay
                flipBackTimer = setTimeout(() => {
                    if (firstCard && !firstCard.matched) {
                        const fEl = cardElements.get(firstCard.id);
                        if (fEl) setCardHidden(fEl, firstCard);
                    }
                    if (secondCard && !secondCard.matched) {
                        const sEl = cardElements.get(secondCard.id);
                        if (sEl) setCardHidden(sEl, secondCard);
                    }
                    firstCard = null;
                    secondCard = null;
                    lockBoard = false;
                    flipBackTimer = null;
                }, 750);
            }
            return;
        }
        
        // Fallback safety reset (if state inconsistent)
        if (firstCard && secondCard) {
            clearPending(true);
            // re-trigger if needed
            if (!lockBoard) handleCardClick(cardId);
        }
    }
    
    // Render grid based on currentCards order
    function renderBoard() {
        gridEl.innerHTML = '';
        cardElements.clear();
        for (let i = 0; i < currentCards.length; i++) {
            const card = currentCards[i];
            const cardDiv = document.createElement('div');
            cardDiv.className = 'card hidden';
            if (card.matched) {
                // matched case: show matched style
                cardDiv.classList.add('matched');
                cardDiv.classList.remove('hidden');
                const span = document.createElement('span');
                span.textContent = card.fruitIcon;
                cardDiv.appendChild(span);
            } else {
                const span = document.createElement('span');
                span.textContent = '';
                span.style.display = 'none';
                cardDiv.appendChild(span);
            }
            cardDiv.addEventListener('click', (e) => {
                e.stopPropagation();
                handleCardClick(card.id);
            });
            gridEl.appendChild(cardDiv);
            cardElements.set(card.id, cardDiv);
            // sync matched visual if needed
            if (card.matched) {
                setCardMatched(cardDiv, card);
            }
        }
        // ensure any leftover flipped cards (none at fresh)
    }
    
    // Completely resets & randomizes everything: new selection of 18 unique produce, shuffle positions
    function initNewGame() {
        // clear any pending timer
        if (flipBackTimer) {
            clearTimeout(flipBackTimer);
            flipBackTimer = null;
        }
        lockBoard = false;
        firstCard = null;
        secondCard = null;
        moves = 0;
        matchedPairsCount = 0;
        
        // Build new deck with fresh 18 distinct fruit/veg images (no repeat across pairs)
        let rawDeck = buildUniqueDeck();
        // Randomize card order
        currentCards = shuffleArray(rawDeck);
        // Reset matched flags
        for (let card of currentCards) {
            card.matched = false;
        }
        updateUI();
        renderBoard();
        messageBox.innerHTML = "🥬 New game! 18 unique pairs. Each card has a unique partner — no repeated images!";
    }
    
    // manual reset button
    resetButton.addEventListener('click', () => {
        if (flipBackTimer) clearTimeout(flipBackTimer);
        lockBoard = false;
        firstCard = null;
        secondCard = null;
        initNewGame();
    });
    
    // ---------- VALIDATION: ensure no duplicate images across pairs ----------
    // In buildUniqueDeck we guarantee 18 distinct produce icons, so across all 36 cards, each fruit/veg appears exactly twice,
    // and no other pair shares the same icon. This satisfies "do not repeat any images" (meaning no two different pairs share same image)
    // Additionally each card's twin is identical icon.
    
    // Let's also test at start (dev console)
    function assertNoImageRepeatsAcrossPairs(deck) {
        const seenIcons = new Set();
        for (let card of deck) {
            if (!seenIcons.has(card.fruitIcon)) {
                seenIcons.add(card.fruitIcon);
            }
        }
        // deck has 36 cards, but distinct icons should be exactly 18 (since each pair shares icon)
        console.log("Distinct icons in current game:", seenIcons.size, " (should be 18)");
        if (seenIcons.size !== 18) console.warn("Icon count mismatch");
        return seenIcons.size === 18;
    }
    
    // start game
    initNewGame();
    
    // Post-initial check (just for robustness)
    setTimeout(() => {
        if (currentCards) assertNoImageRepeatsAcrossPairs(currentCards);
    }, 100);
    
    // Additional guarantee: the produce set includes many vegetables automatically when fruits are exhausted ?
    // Our PRODUCE_SET includes 16 fruits (including tomato) + 11 vegetables = 27 available. We always pick 18 random distinct items.
    // If there are less than 18 fruits available? there are 16 fruits, but we need 18 unique pairs -> we must include at least 2 vegetables.
    // The algorithm automatically selects from entire set, so if fruits are not enough (but we have 16 fruits, needing 18 icons, then it will pick 16 fruits + 2 vegetables)
    // Perfectly respects the rule: "if no more fruits available, use vegetables". Since we randomly pick without bias and have 16 fruits, we always fill remaining with veggies.
    // However we made total distinct items 18 > 16 fruits, so every game will have at least 2 vegetables, but could include more. That's fine, rule respected.
    // There is no scenario where we reuse same fruit/veg across pairs because we enforce distinct selection.


Harvest Match · Unique Memory Cards

✅ Low Risk - https://harvestmatch-k5qoo6gy76.edgeone.app/

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

Security Scan Report: harvestmatch-k5qoo6gy76.edgeone.app

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

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