corporate

English

The domain name 'chronoodle-develop.pages.dev' uses the developer-focused generic top-level domain (.dev) and includes subdomain 'chronoodle-develop'. The core label 'pages' covers 5 characters with two vowels and 3 consonants. Segmentation suggests 1 word: pages. Median word length comes out to 5 characters. No strong language cues emerged from the frequency lists.

html/2b/bf/2bbfc8f4-9295-441c-a877-222d295a7b62.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

9ce753edee8a93a88e476b0e7301b63cb841e8132c68d8d8a77a281cd4728dee

d0e529de872c9aaad01dbb0c4a0d98abe25dbcd70a05d1b4ca33bdaf81da9939

6a00b1393bd74ac062ad19c64062eee1ae9c257e24949b55813a9462a4820e54

423dc908bb28492b3bbf6c476ca2471fa401ceb835bfbc84715a1076722e5506

a1471487eb3e8eb93b1a9e056386019ff5eedadea29bbb725b5494fb2e9ad90a

bead2dc3a1e75394a6dace3bbfb87ea3949d4bb7a706ec61bb25a5e093aa5efb

6368e8cafbe3828cce45c9807cf047b5216e2766b97c44abcc54ccd85ad43645

904842109f42efcef2ec3c77f6fad87238c2e1e2f9c73f146fd68b920eef0062

334e678f04c7ad16bc046f71e87816d456fa8b7397d3d82bfd6b9f4ca6798f3a

000d1914016c87f60e15b7d73043a858923c72197a968a78e9c3cae633331deb

0bcc9f9bee5cd59ab21e43a2b40e1d8134219f5948ca09564412b5015e90e29c

c9221c86c5b7b99837a3aeab887cc74cf51d9273c5dac4a743d343d82be05939

199a971b2be9fbb98f6ff5c59b67771d1618124a11ac14450e6a74ebea07e560

📅
WikiStart
Find the exact date any Wikipedia article was first created. Paste in a URL and get the 

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

viewport

Free tools from the makers of Chronoodle. Look up Wikipedia article creation dates and more.

description

chronoodle, free tools, wikipedia creation date, wiki start date, history tools

keywords

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

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET

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	188.114.96.3	United States	AS13335Cloudflare, Inc.
3	172.66.47.147	United States	AS13335Cloudflare, Inc.
3	20.250.198.32	Zurich, Zurich, Switzerland	AS8075Microsoft Corporation
3	104.21.34.241	United States	AS13335Cloudflare, Inc.
3	142.251.14.95	Switzerland	Unknown
3	192.178.183.94	Switzerland	Unknown
21	6	-	-

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