entertainment media

government public service

adult content

education learning

documentation technical

English

You're looking at domain 'chronoodle-develop.pages.dev' on the developer-focused generic top-level domain (.dev) and includes subdomain 'chronoodle-develop'. The core label 'pages' covers 5 characters containing two vowels alongside three consonants. Tokenizing the label suggests one word: pages. Expect 5 characters per word on average. No strong language cues emerged from the frequency lists.

html/da/e9/dae9d960-913e-4609-a454-2babc982f8ec.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

6e51e2ba34a6db0ea745bf5db7f2bc012b798fd84da7af973594a4fde2f8201b

a1471487eb3e8eb93b1a9e056386019ff5eedadea29bbb725b5494fb2e9ad90a

9ce753edee8a93a88e476b0e7301b63cb841e8132c68d8d8a77a281cd4728dee

d0e529de872c9aaad01dbb0c4a0d98abe25dbcd70a05d1b4ca33bdaf81da9939

6a00b1393bd74ac062ad19c64062eee1ae9c257e24949b55813a9462a4820e54

bead2dc3a1e75394a6dace3bbfb87ea3949d4bb7a706ec61bb25a5e093aa5efb

6368e8cafbe3828cce45c9807cf047b5216e2766b97c44abcc54ccd85ad43645

904842109f42efcef2ec3c77f6fad87238c2e1e2f9c73f146fd68b920eef0062

334e678f04c7ad16bc046f71e87816d456fa8b7397d3d82bfd6b9f4ca6798f3a

000d1914016c87f60e15b7d73043a858923c72197a968a78e9c3cae633331deb

0bcc9f9bee5cd59ab21e43a2b40e1d8134219f5948ca09564412b5015e90e29c

c9221c86c5b7b99837a3aeab887cc74cf51d9273c5dac4a743d343d82be05939

199a971b2be9fbb98f6ff5c59b67771d1618124a11ac14450e6a74ebea07e560

🎃 Check out the Halloween Playlist Collection →

Chronoodle's 18th Century Jams (1700-1799)

Chronoodle's Roaring 20s Hits (1920-1929)

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

viewport

Explore Chronoodle Playlists - curated collections of historical events paired with themed Spotify playlists. Immerse yourself in history through music and timelines.

description

Chronoodle Playlists, historical timelines, Spotify playlists, music and history, educational game

keywords

Chronoodle Playlists - Historical Journeys with Music

https://chronoodle.com/assets/music-playlists/chronoodles-18th-century-jams-playlist-cover.webp

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
10	142.250.154.94	United States	AS15169Google LLC
5	188.114.96.3	United States	AS13335Cloudflare, Inc.
5	142.251.13.95	United States	AS15169Google LLC
5	20.250.198.32	Zurich, Zurich, Switzerland	AS8075Microsoft Corporation
5	104.21.34.241	United States	AS13335Cloudflare, Inc.
5	172.66.47.147	United States	AS13335Cloudflare, Inc.
35	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