English

Domain 'hydrate-npcuuwqkin.edgeone.app' uses the application-focused generic top-level domain (.app); it also runs on subdomain 'hydrate-npcuuwqkin'. The second-level label 'edgeone' is 7 characters long split between 4 vowels and three consonants. Tokenizing the label suggests 2 words: edge, one. Expect 3.5 characters per word on average. No strong language cues emerged from the frequency lists.

html/aa/bd/aabd655c-0770-4570-8fe9-42c6c27f3231.html.gz

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

ae7e8736530fd99cbd7f62f0e76646d1da7696476feaef9e032c1292b44f66d8

viewport

html/aa/bd/aabd655c-0770-4570-8fe9-42c6c27f3231_nodriver.html.gz

Hydrate — Water Reminder

Prudence Malinki

MarkMonitor Inc.

edgeone.app

Abuse

Google LLC

GOOGLE

IRT-SG-ACE

ACE administrator

ACE-SG


  /* ═══════════════════════════════════════════════════════
     STATE
  ═══════════════════════════════════════════════════════ */
  let state = JSON.parse(localStorage.getItem('hydrate') || 'null') || {
    total: 0, goal: 2000, log: [],
    reminder: false, interval: 60,
    lastReset: new Date().toDateString()
  };

  if (state.lastReset !== new Date().toDateString()) {
    state.total = 0; state.log = [];
    state.lastReset = new Date().toDateString();
    save();
  }

  function save() { localStorage.setItem('hydrate', JSON.stringify(state)); }

  /* ═══════════════════════════════════════════════════════
     WAVE ANIMATION — runs at full rAF rate (60/120 fps)
  ═══════════════════════════════════════════════════════ */
  let waveT = 0;
  const W = 170, H = 210;

  // Pre-allocate path string buffer
  function buildWave(yBase, amp, speed, phase) {
    const pts = [];
    pts.push(`M -20,${yBase}`);
    for (let x = -20; x <= W + 20; x += 3) {
      const y = yBase - amp * Math.sin((x * 0.055) + waveT * speed + phase);
      pts.push(`L ${x},${y}`);
    }
    pts.push(`L ${W+20},${H} L -20,${H} Z`);
    return pts.join(' ');
  }

  // Smooth fill target using lerp
  let fillY    = H;         // current SVG y (H = empty, 0 = full)
  let fillYTarget = H;

  const fillEl  = document.getElementById('waterFill');
  const wave1   = document.getElementById('wavePath1');
  const wave2   = document.getElementById('wavePath2');
  const amtEl   = document.getElementById('waterAmt');

  function loop() {
    waveT += 0.018;   // increment — controls wave speed

    // Lerp fill toward target (smooth at any fps)
    const diff = fillYTarget - fillY;
    if (Math.abs(diff) > 0.05) {
      fillY += diff * 0.06;   // easing factor — lower = smoother/slower
    } else {
      fillY = fillYTarget;
    }

    fillEl.setAttribute('y', fillY.toFixed(2));

    const yBase = fillY + 2;
    wave1.setAttribute('d', buildWave(yBase, 4.5, 1.0, 0));
    wave2.setAttribute('d', buildWave(yBase + 3, 3.5, 0.75, 2.1));

    requestAnimationFrame(loop);
  }
  requestAnimationFrame(loop);

  function setFillTarget(pct) {
    fillYTarget = H * (1 - Math.min(pct, 1));
  }

  /* ═══════════════════════════════════════════════════════
     RENDER
  ═══════════════════════════════════════════════════════ */
  function render() {
    const pct = Math.min(state.total / state.goal, 1);
    setFillTarget(pct);

    amtEl.textContent = state.total;
    document.getElementById('goalText').textContent  = `Goal: ${state.goal} ml`;
    document.getElementById('goalVal').textContent   = `${state.goal} ml`;
    document.getElementById('percentStat').textContent = Math.round(pct * 100) + '%';
    document.getElementById('remainStat').textContent  = Math.max(0, state.goal - state.total);
    document.getElementById('logCount').textContent    = state.log.length;

    // pop animation on stats
    ['percentStat','remainStat','logCount'].forEach(id => {
      const el = document.getElementById(id);
      el.classList.remove('pop');
      void el.offsetWidth;
      el.classList.add('pop');
      setTimeout(() => el.classList.remove('pop'), 300);
    });

    // Completion
    const comp = document.getElementById('completion');
    const wasComplete = comp.classList.contains('show');
    const isComplete  = state.total >= state.goal;
    comp.classList.toggle('show', isComplete);
    if (isComplete && !wasComplete) playCheerSound();

    // Log
    const list = document.getElementById('logList');
    if (state.log.length === 0) {
      list.innerHTML = '<div class="empty-log">No water logged yet. Stay hydrated! 💙</div>';
    } else {
      list.innerHTML = [...state.log].reverse().map((item, i) => `
        <div class="log-item">
          <div class="log-left">
            <span class="log-icon">💧</span>
            <span class="log-ml">+${item.amount} ml</span>
          </div>
          <span class="log-time">${item.time}</span>
          <button class="log-delete" onclick="deleteLog(${state.log.length - 1 - i})">✕</button>
        </div>`).join('');
    }

    // Toggle
    const toggle = document.getElementById('toggle');
    toggle.classList.toggle('on', state.reminder);
    document.getElementById('reminderStatus').textContent = state.reminder
      ? `Notifying every ${state.interval} min` : 'Enable to get notified';
    document.getElementById('intervalSelect').value = state.interval;
  }

  /* ═══════════════════════════════════════════════════════
     ACTIONS
  ═══════════════════════════════════════════════════════ */
  function addWater(ml) {
    state.total += ml;
    state.log.push({ amount: ml, time: new Date().toLocaleTimeString([], {hour:'2-digit',minute:'2-digit'}) });
    save(); render(); playWaterSound();
    showToast(`+${ml} ml added 💧`);
  }

  function addCustom() {
    const raw = parseFloat(document.getElementById('customMl').value);
    const mul = parseInt(document.getElementById('unitSelect').value);
    const v   = Math.round(raw * mul);
    if (!raw || raw <= 0 || v > 10000) { showToast('Enter a valid amount'); return; }
    addWater(v);
    document.getElementById('customMl').value = '';
  }

  function deleteLog(index) {
    state.total = Math.max(0, state.total - state.log[index].amount);
    state.log.splice(index, 1);
    save(); render(); playWaterSound();
  }

  function adjustGoal(delta) {
    state.goal = Math.max(500, Math.min(5000, state.goal + delta));
    // bump animation
    const gv = document.getElementById('goalVal');
    gv.classList.remove('bump'); void gv.offsetWidth; gv.classList.add('bump');
    setTimeout(() => gv.classList.remove('bump'), 300);
    save(); render(); playWaterSound();
    showToast(`Goal: ${state.goal} ml`);
  }

  function toggleReminder() {
    state.reminder = !state.reminder;
    save();
    if (state.reminder) { requestNotificationPermission(); startReminders(); }
    else { clearInterval(reminderTimer); reminderTimer = null; }
    render(); playWaterSound();
  }

  function updateInterval() {
    state.interval = parseInt(document.getElementById('intervalSelect').value);
    save();
    if (state.reminder) { clearInterval(reminderTimer); startReminders(); }
    render(); playWaterSound();
  }

  function resetDay() {
    state.total = 0; state.log = [];
    save(); render(); playWaterSound();
    showToast('Day reset! 🌊');
  }

  /* ═══════════════════════════════════════════════════════
     REMINDERS
  ═══════════════════════════════════════════════════════ */
  let reminderTimer = null;

  function startReminders() {
    clearInterval(reminderTimer);
    reminderTimer = setInterval(() => {
      const rem = Math.max(0, state.goal - state.total);
      if (rem > 0) {
        showNativeNotif(`Time to drink water! 💧 ${rem} ml remaining.`);
        showToast('💧 Time to hydrate!');
      }
    }, state.interval * 60000);
  }

  function requestNotificationPermission() {
    if ('Notification' in window && Notification.permission === 'default')
      Notification.requestPermission();
  }

  function showNativeNotif(body) {
    if ('Notification' in window && Notification.permission === 'granted')
      new Notification('Hydrate Reminder', { body, icon: '💧' });
    playWaterSound();
  }

  /* ═══════════════════════════════════════════════════════
     TOAST
  ═══════════════════════════════════════════════════════ */
  let toastTimeout;
  function showToast(msg) {
    const t = document.getElementById('toast');
    t.textContent = msg;
    t.classList.add('show');
    clearTimeout(toastTimeout);
    toastTimeout = setTimeout(() => t.classList.remove('show'), 2200);
  }

  /* ═══════════════════════════════════════════════════════
     AUDIO
  ═══════════════════════════════════════════════════════ */
  let _audioCtx = null;
  function getAudioCtx() {
    if (!_audioCtx || _audioCtx.state === 'closed')
      _audioCtx = new (window.AudioContext || window.webkitAudioContext)();
    if (_audioCtx.state === 'suspended') _audioCtx.resume();
    return _audioCtx;
  }

  function playWaterSound() {
    try {
      const ctx = getAudioCtx();
      const t   = ctx.currentTime;

      function drop(when, baseFreq, vol) {
        const osc = ctx.createOscillator(), gain = ctx.createGain(), lpf = ctx.createBiquadFilter();
        lpf.type = 'lowpass'; lpf.frequency.value = 3200;
        osc.type = 'sine';
        osc.frequency.setValueAtTime(baseFreq * 2.4, when);
        osc.frequency.exponentialRampToValueAtTime(baseFreq * 0.55, when + 0.055);
        osc.frequency.exponentialRampToValueAtTime(baseFreq * 0.38, when + 0.30);
        gain.gain.setValueAtTime(0.0001, when);
        gain.gain.linearRampToValueAtTime(vol, when + 0.007);
        gain.gain.exponentialRampToValueAtTime(0.0001, when + 0.55);
        osc.connect(lpf); lpf.connect(gain); gain.connect(ctx.destination);
        osc.start(when); osc.stop(when + 0.6);
      }
      function bubble(when, freq, vol) {
        const osc = ctx.createOscillator(), gain = ctx.createGain();
        osc.type = 'sine';
        osc.frequency.setValueAtTime(freq, when);
        osc.frequency.linearRampToValueAtTime(freq * 1.7, when + 0.045);
        gain.gain.setValueAtTime(vol, when);
        gain.gain.exponentialRampToValueAtTime(0.0001, when + 0.09);
        osc.connect(gain); gain.connect(ctx.destination);
        osc.start(when); osc.stop(when + 0.1);
      }
      function splash(when, vol) {
        const len = Math.floor(ctx.sampleRate * 0.10);
        const buf = ctx.createBuffer(1, len, ctx.sampleRate);
        const d   = buf.getChannelData(0);
        for (let i = 0; i < len; i++) d[i] = Math.random() * 2 - 1;
        const src = ctx.createBufferSource(), gain = ctx.createGain(), bpf = ctx.createBiquadFilter();
        bpf.type = 'bandpass'; bpf.frequency.value = 1600; bpf.Q.value = 1.2;
        src.buffer = buf;
        gain.gain.setValueAtTime(vol, when);
        gain.gain.exponentialRampToValueAtTime(0.0001, when + 0.10);
        src.connect(bpf); bpf.connect(gain); gain.connect(ctx.destination);
        src.start(when); src.stop(when + 0.11);
      }
      drop(t, 920, 0.42); splash(t, 0.08);
      bubble(t+0.05, 1200, 0.12); bubble(t+0.12, 850, 0.08);
      drop(t+0.30, 680, 0.20);   bubble(t+0.36, 980, 0.06);
      splash(t+0.30, 0.04);
    } catch(e) {}
  }

  function playCheerSound() {
    try {
      const ctx = getAudioCtx(), t = ctx.currentTime;
      [523,659,784,1047,1319].forEach((freq,i) => {
        const osc = ctx.createOscillator(), gain = ctx.createGain();
        osc.type = 'triangle';
        osc.frequency.setValueAtTime(freq, t + i*0.13);
        gain.gain.setValueAtTime(0.0001, t + i*0.13);
        gain.gain.linearRampToValueAtTime(0.28, t + i*0.13 + 0.02);
        gain.gain.exponentialRampToValueAtTime(0.0001, t + i*0.13 + 0.25);
        osc.connect(gain); gain.connect(ctx.destination);
        osc.start(t + i*0.13); osc.stop(t + i*0.13 + 0.3);
      });
      [1568,2093,2637,2093,1568].forEach((freq,i) => {
        const osc = ctx.createOscillator(), gain = ctx.createGain();
        osc.type = 'sine'; osc.frequency.value = freq;
        const st = t + 0.7 + i*0.09;
        gain.gain.setValueAtTime(0.0001, st);
        gain.gain.linearRampToValueAtTime(0.18, st+0.015);
        gain.gain.exponentialRampToValueAtTime(0.0001, st+0.18);
        osc.connect(gain); gain.connect(ctx.destination);
        osc.start(st); osc.stop(st+0.2);
      });
      const len = Math.floor(ctx.sampleRate*1.2);
      const buf = ctx.createBuffer(1,len,ctx.sampleRate);
      const d   = buf.getChannelData(0);
      for (let i = 0; i < len; i++) d[i] = Math.random()*2-1;
      const src  = ctx.createBufferSource(), g2 = ctx.createGain(), hpf = ctx.createBiquadFilter();
      hpf.type = 'highpass'; hpf.frequency.value = 800;
      src.buffer = buf;
      g2.gain.setValueAtTime(0.0001, t+0.6); g2.gain.linearRampToValueAtTime(0.09, t+0.7);
      g2.gain.exponentialRampToValueAtTime(0.0001, t+1.8);
      src.connect(hpf); hpf.connect(g2); g2.connect(ctx.destination);
      src.start(t+0.6); src.stop(t+1.85);
      [523,659,784,1047].forEach(freq => {
        const osc = ctx.createOscillator(), gain = ctx.createGain();
        osc.type = 'sine'; osc.frequency.value = freq;
        gain.gain.setValueAtTime(0.0001, t+1.5);
        gain.gain.linearRampToValueAtTime(0.15, t+1.55);
        gain.gain.exponentialRampToValueAtTime(0.0001, t+2.2);
        osc.connect(gain); gain.connect(ctx.destination);
        osc.start(t+1.5); osc.stop(t+2.3);
      });
    } catch(e) {}
  }

  /* ═══════════════════════════════════════════════════════
     BUBBLES
  ═══════════════════════════════════════════════════════ */
  (function createBubbles() {
    const container = document.getElementById('bubbles');
    for (let i = 0; i < 10; i++) {
      const b    = document.createElement('div');
      b.classList.add('bubble');
      const size = Math.random() * 45 + 8;
      b.style.cssText = `
        width:${size}px; height:${size}px;
        left:${Math.random()*100}%;
        animation-duration:${Math.random()*13+8}s;
        animation-delay:${Math.random()*12}s;
      `;
      container.appendChild(b);
    }
  })();

  /* ═══════════════════════════════════════════════════════
     INIT
  ═══════════════════════════════════════════════════════ */
  document.getElementById('customMl').addEventListener('keydown', e => {
    if (e.key === 'Enter') addCustom();
  });

  if (state.reminder) startReminders();
  render();


✅ Low Risk - https://hydrate-npcuuwqkin.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
4	142.250.201.67	United States	AS15169
2	43.152.26.58	Singapore	AS139341ACE
2	142.251.140.170	United States	Unknown
8	3	-	-

Security Scan Report: hydrate-npcuuwqkin.edgeone.app

Summary

AI Security Verdict

Safe Website

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