documentation technical

technology software

entertainment media

phishing scam

corporate

English

The domain 'chronoodle-develop.pages.dev' uses the developer-focused generic top-level domain (.dev) with subdomain 'chronoodle-develop'. The second-level label 'pages' is 5 characters long with two vowels and three consonants. It segments into 1 word: pages. No strong language cues emerged from the frequency lists.

html/30/f5/30f5e790-228b-4900-8157-c8d007a3f949.html.gz

frame-ancestors https://iframe.chronoodle.com https://oodlegames.itch.io https://html-classic.itch.zone https://itch.io https://likewordle.com

appId=cid-v1:a894a21c-0197-44e5-b203-3cbc01252c82

default-src 'self'; img-src 'self' https: data:; script-src 'self' 'unsafe-eval' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self' https:; frame-ancestors 'self' ;

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

appId=cid-v1:a449a586-8786-487f-a449-dc1b282a2628

57fca6fc12b1e4a353dcde60855c0e392c3ea36d56cfef90475815474c9ead50

a1471487eb3e8eb93b1a9e056386019ff5eedadea29bbb725b5494fb2e9ad90a

a8dd61b77df4b59e44dd50e60eb995377007a3dfce2b5e18f0842062c7571f47

9ce753edee8a93a88e476b0e7301b63cb841e8132c68d8d8a77a281cd4728dee

1d4afcc20dd0772a72c33409af10dafde515b67ffdc71dd7989b88975b373f9c

d0e529de872c9aaad01dbb0c4a0d98abe25dbcd70a05d1b4ca33bdaf81da9939

b6afe345743904a9a9603400be82f8ff0b9d3227e40f9899c2a90fb905a7bf33

bead2dc3a1e75394a6dace3bbfb87ea3949d4bb7a706ec61bb25a5e093aa5efb

6368e8cafbe3828cce45c9807cf047b5216e2766b97c44abcc54ccd85ad43645

904842109f42efcef2ec3c77f6fad87238c2e1e2f9c73f146fd68b920eef0062

334e678f04c7ad16bc046f71e87816d456fa8b7397d3d82bfd6b9f4ca6798f3a

000d1914016c87f60e15b7d73043a858923c72197a968a78e9c3cae633331deb

0bcc9f9bee5cd59ab21e43a2b40e1d8134219f5948ca09564412b5015e90e29c

c9221c86c5b7b99837a3aeab887cc74cf51d9273c5dac4a743d343d82be05939

199a971b2be9fbb98f6ff5c59b67771d1618124a11ac14450e6a74ebea07e560

width=device-width, initial-scale=1.0, viewport-fit=cover, interactive-widget=resizes-content

viewport

Read the Terms and Conditions for using Chronoodle. Understand your rights and responsibilities while enjoying our historical challenge game.

description

Chronoodle terms and conditions, game rules, user agreement, legal

keywords

https://chronoodle.com/assets/chronoodle.png

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Google LLC

GOOGLE

window.chronoodleConfig={"environment":"develop","saveSessionDataEndpoint":"https://develop-v2.chronoodle.com/api/save-session-data","saveReferralEndpoint":"https://develop-v2.chronoodle.com/api/save-referral-data","loginUrl":"https://develop.oodle-games.pages.dev/login","logoutUrl":"https://develop.oodle-games.pages.dev/logout","myAccountUrl":"https://develop.oodle-games.pages.dev/my-account","oodleGamesStoreJwtEndpoint":"https://develop.oodle-games.pages.dev/data-access/store-jwt","apiBaseUrl":"https://develop-v2.chronoodle.com","webBaseUrl":"https://develop.chronoodle.com"};


    // Querystring option to disable analytics on a browser
    (function() {
      const queryString = window.location.search;
      const urlParams = new URLSearchParams(queryString);
      const analyticsOff = urlParams.get('an0') !== null;
      const analyticsOn = urlParams.get('an1') !== null;

      if(analyticsOff) {
        localStorage.setItem('umami.disabled', '1');
      }

      if(analyticsOn) {
        localStorage.removeItem('umami.disabled');
      }
    })();



  if (!localStorage.getItem('umami.disabled')) {
    // Clarity
    (function(c,l,a,r,i,t,y){
        c[a]=c[a]||function(){(c[a].q=c[a].q||[]).push(arguments)};
        t=l.createElement(r);t.async=1;t.src="https://www.clarity.ms/tag/"+i;
        y=l.getElementsByTagName(r)[0];y.parentNode.insertBefore(t,y);
    })(window, document, "clarity", "script", "nu5fqyvshu");

    // Umami
    const script = document.createElement('script');
    script.defer = true;
    script.src = "https://umami.doogi.io/script.js";
    script.setAttribute("data-website-id", "2797e403-81db-4b7e-a30a-ce47a8fafe38");
    document.head.appendChild(script);
  } else {
    document.addEventListener('DOMContentLoaded', () => {
      Utils.addMarker('🔕', 'Analytics are disabled');
    });
  }


class OodleApi {
  constructor() {
    this.baseUrl = window.chronoodleConfig.apiBaseUrl;
    this.POST_QUEUE_KEY = 'postQueue';
    this.isFlushingQueue = false; // In-memory queue lock
  }

  async init() {
    this.runQueuedPosts(); // fire-and-forget
    setInterval(() => this.runQueuedPosts(), 30000); // every 30s
  }

  async post(endpoint, payload = {}, minimumDuration = 0) {
    return this.call(endpoint, payload, 'POST', minimumDuration);
  }

  // async enqueuePost(endpoint, payload = {}, minimumDuration = 0, runNow = true) {
  //   const queue = JSON.parse(localStorage.getItem(this.POST_QUEUE_KEY) || '[]');
  //   queue.push({
  //     endpoint,
  //     payload,
  //     timestamp: Date.now()
  //   });
  //   localStorage.setItem(this.POST_QUEUE_KEY, JSON.stringify(queue));

  //   if(runNow) {
  //     return await this.runQueuedPosts(false);
  //   }

  //   return { queued: true };
  // }
  async enqueuePost(endpoint, payload = {}, minimumDuration = 0, runNow = true) {
    // if(Utils.isReadonly()) {
    //   return { queued: true, reason: 'is readonly' };
    // }

    // Wait if another enqueue is happening
    while (this.isEnqueuing) {
      await new Promise(resolve => setTimeout(resolve, 10)); // ⏳ Wait 10ms
    }
  
    this.isEnqueuing = true;
  
    try {
      const key = this.POST_QUEUE_KEY;
      const queue = JSON.parse(localStorage.getItem(key) || '[]');
      
      queue.push({
        endpoint,
        payload,
        timestamp: Date.now()
      });
  
      localStorage.setItem(key, JSON.stringify(queue));
    } catch (err) {
      console.error("Failed to enqueue post:", err);
    } finally {
      this.isEnqueuing = false;
    }
  
    if (runNow) {
      // Yield to microtask queue to ensure write commits
      await Promise.resolve();
      return await this.runQueuedPosts(false);
    }
  
    return { queued: true };
  }
  

  async get(endpoint, payload = {}, minimumDuration = 0) {
    return this.call(endpoint, payload, 'GET', minimumDuration);
  }

  async patch(endpoint, payload = {}, minimumDuration = 0) {
    return this.call(endpoint, payload, 'PATCH', minimumDuration);
  }

  async call(endpoint, payload = {}, method = 'POST', minimumDuration = 0) {
    let url = this.baseUrl + endpoint;

    // Auto-convert payload to query string for GET requests
    if (method === 'GET' && Object.keys(payload).length > 0) {
      const queryParams = new URLSearchParams(payload).toString();
      url += (url.includes('/?') ? '&' : '/?') + queryParams;
    }
    
    //const jwt = Utils.getFromStorage('jwt');
    const jwt = Utils.Jwt.getJwt();
    const headers = { 'Content-Type': 'application/json' };
    if (jwt) {
      headers['Authorization'] = 'Bearer ' + jwt;
    }

    const isReadonly = Utils.isReadonly();
    if(isReadonly) {
      headers['X-Chronoodle-Readonly'] = 'true';
    }

    const payloadMethods = ['POST', 'PUT', 'PATCH'];
    const response = await this.fetchWithMinimumDuration(url, {
      method,
      headers,
      body: payloadMethods.includes(method) ? JSON.stringify(payload) : null
    }, minimumDuration);

    const contentType = response.headers.get('Content-Type') || '';

    if (!response.ok) {
      //const responseObject = await response.json();
      throw new Error(JSON.stringify({
          status: response.status,
          statusText: response.statusText,
          //response: responseObject
      }));
    }

    if (contentType.includes('application/json')) {
      return response.json();
    }
    if (contentType.includes('text/plain')) {
      return response.text();
    }

    throw new Error(`Unsupported content type: ${contentType}`);
  }

  /**
     * A fetch wrapper that ensures the operation lasts at least a minimum duration.
     *
     * @param {string} url - The resource URL.
     * @param {object} options - The fetch options (headers, body, method, etc.).
     * @param {number} minDuration - The minimum time (in milliseconds) the operation should take.
     * @returns {Promise<Response>} - The fetch Response object.
     */
  async fetchWithMinimumDuration(url, options = {}, minDuration = 0) {
      const startTime = Date.now();

      // Perform the fetch
      const fetchPromise = fetch(url, options);

      // Ensure the operation lasts at least `minDuration` ms
      const delayPromise = new Promise((resolve) => {
          const elapsed = Date.now() - startTime;
          const remainingTime = Math.max(minDuration - elapsed, 0);
          setTimeout(resolve, remainingTime);
      });

      // Wait for both the fetch and the minimum duration
      const [response] = await Promise.all([fetchPromise, delayPromise]);

      return response;
  }

  async runQueuedPosts(throttle = true) {
    // Prevent overlapping runs
    if (this.flushPromise) {
      return this.flushPromise;
    }
  
    let resolveFlush;
    this.flushPromise = new Promise(resolve => resolveFlush = resolve);
  
    let result = { sent: false, remaining: 0 };
  
    try {
      const key = this.POST_QUEUE_KEY;
      let queue = JSON.parse(localStorage.getItem(key) || '[]');
      if (queue.length === 0) {
        return result;
      }
  
      while (queue.length > 0) {
        const item = queue[0];

        try {
          await this.post(item.endpoint, item.payload);
          queue.shift(); // ✅ Success
        } catch (err) {
          const status = JSON.parse(err.message).status;

          if (status === 403) {
            console.warn(`Post removed due to read-only restriction: ${item.endpoint}`);
            queue.shift(); // ✅ Remove it permanently
          } else {
            console.warn(`Post failed for ${item.endpoint}:`, err?.message || err);
            break; // ❌ Retry later
          }
        }

        if (queue.length === 0) {
          console.log('Post queue cleared!');
          localStorage.removeItem(key);
        } else {
          localStorage.setItem(key, JSON.stringify(queue));
        }

        if (throttle) {
          await new Promise(res => setTimeout(res, 1000));
        }
      }

  
      result = {
        sent: true,
        remaining: queue.length
      };
    } finally {
      resolveFlush();              // 💥 Release all waiters
      this.flushPromise = null;    // 🔓 Unlock future calls
    }
  
    return result;
  }
  
  // async runQueuedPosts(throttle = true) {
  //   if (this.isFlushingQueue) {
  //     return;
  //   }
  //   this.isFlushingQueue = true;
  
  //   let result = { sent: false, remaining: 0 };
  
  //   try {
  //     const key = this.POST_QUEUE_KEY;
  //     let queue = JSON.parse(localStorage.getItem(key) || '[]');
  //     if (queue.length === 0) {
  //       return result;
  //     }
  
  //     while (queue.length > 0) {
  //       const item = queue[0];
  
  //       try {
  //         await this.post(item.endpoint, item.payload);
  //         queue.shift();
  
  //         if (queue.length === 0) {
  //           console.log('Post queue cleared!');
  //           localStorage.removeItem(key);
  //         } else {
  //           localStorage.setItem(key, JSON.stringify(queue));
  //         }
  
  //         if (throttle) {
  //           await new Promise(res => setTimeout(res, 1000));
  //         }
  //       } catch (err) {
  //         console.warn(`Post failed for ${item.endpoint}:`, err?.message || err);
  //         break;
  //       }
  //     }
  
  //     result = {
  //       sent: true,
  //       remaining: queue.length
  //     };
  //   } finally {
  //     this.isFlushingQueue = false;
  //   }
  
  //   return result;
  // }
  

  // async runQueuedPosts(throttle = true) {
  //   if (this.isFlushingQueue) {
  //     return; // 🚧 Prevent overlapping runs
  //   }
  //   this.isFlushingQueue = true;

  //   try {
  //     const key = this.POST_QUEUE_KEY;
  //     let queue = JSON.parse(localStorage.getItem(key) || '[]');
  //     if (queue.length === 0) {
  //       return { sent: false, remaining: 0 };
  //     }
    
  //     while (queue.length > 0) {
  //       const item = queue[0]; // Always grab the first
    
  //       try {
  //         await this.post(item.endpoint, item.payload);
  //         queue.shift(); // ✅ Remove from queue on success
    
  //         if (queue.length === 0) {
  //           console.log('Post queue cleared!');
  //           localStorage.removeItem(key); // 🔥 Wipe it clean if we're done
  //         } else {
  //           localStorage.setItem(key, JSON.stringify(queue)); // 💾 Save progress
  //         }
    
  //         if(throttle) {
  //           await new Promise(res => setTimeout(res, 1000)); // ⏱ Throttle
  //         }
    
  //       } catch (err) {
  //         console.warn(`Post failed for ${item.endpoint}:`, err?.message || err);
  //         // ❌ Do not shift; stop processing
  //         break;
  //       }
  //     }
    
  //     return {
  //       sent: true,
  //       remaining: queue.length
  //     };
  //   } finally {
  //     this.isFlushingQueue = false; // Release queue lock
  //   }
  // };
};

Requests	IP Address	Location	AS Autonomous System
6	192.178.183.94	United States	AS15169Google LLC
3	20.250.198.32	Zurich, Zurich, Switzerland	AS8075Microsoft Corporation
3	192.178.183.95	United States	AS15169Google LLC
3	172.66.44.109	United States	AS13335Cloudflare, Inc.
3	188.114.97.3	United States	Unknown
3	104.21.34.241	United States	AS13335Cloudflare, Inc.
21	6	-	-

Security Scan Report: chronoodle-develop.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 Technologies4

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