education learning

news media journalism

adult content

Chinese

Domain 'dailycounter-dpndab0qqb72.edgeone.app' uses the application-focused generic top-level domain (.app) and includes subdomain 'dailycounter-dpndab0qqb72'. Its registrable label 'edgeone' stretches across 7 characters holding four vowels versus 3 consonants. Segmentation suggests 2 words: edge, one. Expect 3.5 characters per word on average. No strong language cues emerged from the frequency lists.

html/1e/b9/1eb97bbc-17e2-440e-ad33-2996d9a15aa4.html.gz

33b02cc202076f66f7dd01c40b91f25e1b05e99d7cd914bcb93932558334a6fb

176e894661aa9cdc9a5cba6c720044cbbf7b8bd80d1c9a142a7c24b1b6c50d15

0c78d42b3a28ea6fcfdb42307085e7a6346585aa6395d6731b33324a708c3b10

a5db96bce4ad1abe601de8e6286734aaf2481958024699c5fb514501b48fd736

a06e9023133cd6b906f0a52f7a5d16d96d9d78bcf3216945d8fb767c00c2be9b

width=device-width, initial-scale=1.0, viewport-fit=cover

viewport

theme-color

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


    const { createApp, computed, reactive, ref, watch } = Vue;

    const STORAGE_KEY = 'daily-flow-v1';

    const defaultTypes = [
      { id: 'work', name: '工作', color: '#2563eb' },
      { id: 'sleep', name: '睡觉', color: '#111827' },
      { id: 'play', name: '娱乐', color: '#f97316' },
      { id: 'eat', name: '吃饭', color: '#22c55e' },
      { id: 'study', name: '学习', color: '#a855f7' }
    ];

    const weekNames = ['一', '二', '三', '四', '五', '六', '日'];

    function pad(num) {
      return String(num).padStart(2, '0');
    }

    function dateKey(date) {
      const d = normalizeDate(date);
      return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
    }

    function normalizeDate(date) {
      return new Date(date.getFullYear(), date.getMonth(), date.getDate());
    }

    function parseDateKey(key) {
      const [year, month, day] = key.split('-').map(Number);
      return new Date(year, month - 1, day);
    }

    function formatDate(date) {
      const d = normalizeDate(date);
      const week = weekNames[(d.getDay() + 6) % 7];
      return `${d.getFullYear()}年${d.getMonth() + 1}月${d.getDate()}日 周${week}`;
    }

    function monthTitle(year, month) {
      return `${year}年${month + 1}月`;
    }

    function readableText(hex) {
      const clean = String(hex || '#ffffff').replace('#', '');
      const r = parseInt(clean.slice(0, 2), 16);
      const g = parseInt(clean.slice(2, 4), 16);
      const b = parseInt(clean.slice(4, 6), 16);
      const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
      return luminance > 0.62 ? '#0f172a' : '#ffffff';
    }

    function createId(prefix) {
      return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
    }

    function cloneTypes(types) {
      return types.map(type => ({ ...type }));
    }

    const ViewHeader = {
      props: ['title', 'subtitle'],
      template: `
        <div class="mb-4 flex items-center justify-between">
          <div>
            <p class="text-sm text-slate-500">{{ subtitle || '' }}</p>
            <h2 class="text-2xl font-black">{{ title }}</h2>
          </div>
        </div>
      `
    };

    createApp({
      components: { ViewHeader },
      setup() {
        const storage = loadStorage();

        const activeTab = ref('today');
        const currentDate = ref(normalizeDate(new Date()));
        const selectedType = ref(storage.types[0].id);
        const showPicker = ref(false);
        const showReset = ref(false);
        const year = ref(new Date().getFullYear());
        const month = ref(new Date().getMonth());
        const today = normalizeDate(new Date());

        const scheduleTypes = reactive(storage.types);
        const dailyData = reactive(storage.dailyData);

        const hours = Array.from({ length: 24 }, (_, index) => index);

        const pickerValues = computed({
          get() {
            const d = normalizeDate(currentDate.value);
            return [d.getFullYear(), d.getMonth() + 1, d.getDate()];
          },
          set(value) {
            const [y, m, d] = value;
            currentDate.value = new Date(y, m - 1, d);
          }
        });

        const resetActions = [
          { name: '清空当前日期数据', date: 'current' },
          { name: '清空全部数据', date: 'all' },
          { name: '取消' }
        ];

        const todayRecord = computed(() => dailyData[dateKey(currentDate.value)] || {});

        const todaySegments = computed(() => buildSegments(currentDate.value));

        const todayTotalHours = computed(() => todaySegments.value.reduce((sum, item) => sum + item.hours, 0));

        const weekStart = computed(() => startOfWeek(currentDate.value));

        const weekDays = computed(() => Array.from({ length: 7 }, (_, index) => {
          const date = new Date(weekStart.value);
          date.setDate(weekStart.value.getDate() + index);
          return {
            key: dateKey(date),
            date,
            label: `周${weekNames[index]}`
          };
        }));

        const weekRangeText = computed(() => {
          const start = weekDays.value[0].date;
          const end = weekDays.value[6].date;
          return `${start.getMonth() + 1}/${start.getDate()} - ${end.getMonth() + 1}/${end.getDate()}`;
        });

        const weekSegments = computed(() => buildRangeSegments(weekDays.value.map(day => day.date)));

        const monthCells = computed(() => {
          const first = new Date(year.value, month.value, 1);
          const startOffset = (first.getDay() + 6) % 7;
          const daysInMonth = new Date(year.value, month.value + 1, 0).getDate();
          const cells = [];

          for (let i = 0; i < startOffset; i++) {
            cells.push({ key: `blank-${i}` });
          }

          for (let day = 1; day <= daysInMonth; day++) {
            const date = new Date(year.value, month.value, day);
            cells.push({
              key: dateKey(date),
              date
            });
          }

          while (cells.length % 7 !== 0) {
            cells.push({ key: `blank-end-${cells.length}` });
          }

          return cells;
        });

        const monthTitleText = computed(() => monthTitle(year.value, month.value));

        const yearData = computed(() => {
          const result = [];
          for (let monthIndex = 0; monthIndex < 12; monthIndex++) {
            const days = getMonthDays(year.value, monthIndex);
            const total = days.reduce((sum, day) => sum + day.hours, 0);
            result.push({ monthIndex, days, total });
          }
          return result;
        });

        function loadStorage() {
          try {
            const raw = localStorage.getItem(STORAGE_KEY);
            if (!raw) {
              return {
                types: cloneTypes(defaultTypes),
                dailyData: {}
              };
            }
            const parsed = JSON.parse(raw);
            return {
              types: Array.isArray(parsed.types) && parsed.types.length ? parsed.types : cloneTypes(defaultTypes),
              dailyData: parsed.dailyData || {}
            };
          } catch {
            return {
              types: cloneTypes(defaultTypes),
              dailyData: {}
            };
          }
        }

        function save() {
          localStorage.setItem(STORAGE_KEY, JSON.stringify({
            types: scheduleTypes,
            dailyData
          }));
        }

        watch([scheduleTypes, dailyData], save, { deep: true });

        function getRecord(date) {
          return dailyData[dateKey(date)] || {};
        }

        function setRecord(date, record) {
          const key = dateKey(date);
          if (Object.keys(record).length) {
            dailyData[key] = record;
          } else {
            delete dailyData[key];
          }
        }

        function toggleHour(hour) {
          const record = { ...(dailyData[dateKey(currentDate.value)] || {}) };
          if (record[hour] === selectedType.value) {
            delete record[hour];
          } else {
            record[hour] = selectedType.value;
          }
          setRecord(currentDate.value, record);
        }

        function cellColor(hour) {
          const typeId = todayRecord.value[hour];
          if (!typeId) return '';
          const type = scheduleTypes.find(item => item.id === typeId);
          return type ? type.color : '';
        }

        function buildSegments(date) {
          const record = getRecord(date);
          const counts = scheduleTypes.map(type => ({ type, hours: 0 }));
          Object.values(record).forEach(typeId => {
            const target = counts.find(item => item.type.id === typeId);
            if (target) target.hours += 1;
          });
          const total = counts.reduce((sum, item) => sum + item.hours, 0);
          return counts
            .filter(item => item.hours > 0)
            .map(item => ({
              ...item,
              percent: total ? Math.round((item.hours / total) * 100) : 0
            }));
        }

        function buildRangeSegments(dates) {
          const counts = scheduleTypes.map(type => ({ type, hours: 0 }));
          dates.forEach(date => {
            Object.values(getRecord(date)).forEach(typeId => {
              const target = counts.find(item => item.type.id === typeId);
              if (target) target.hours += 1;
            });
          });
          const total = counts.reduce((sum, item) => sum + item.hours, 0);
          return counts
            .filter(item => item.hours > 0)
            .map(item => ({
              ...item,
              percent: total ? Math.round((item.hours / total) * 100) : 0
            }));
        }

        function getDaySegments(date) {
          const segments = buildSegments(date);
          const total = segments.reduce((sum, item) => sum + item.percent, 0);
          if (segments.length && total !== 100 && segments.length) {
            segments[segments.length - 1].percent += 100 - total;
          }
          return segments;
        }

        function getDayTotalHours(date) {
          return Object.keys(getRecord(date)).length;
        }

        function dominantCellColor(date) {
          const record = getRecord(date);
          if (!Object.keys(record).length) return '#f8fafc';
          const counts = {};
          Object.values(record).forEach(typeId => {
            counts[typeId] = (counts[typeId] || 0) + 1;
          });
          const topId = Object.entries(counts).sort((a, b) => b[1] - a[1])[0][0];
          const type = scheduleTypes.find(item => item.id === topId);
          return type ? type.color : '#f8fafc';
        }

        function topTypeName(date) {
          const record = getRecord(date);
          if (!Object.keys(record).length) return '';
          const counts = {};
          Object.values(record).forEach(typeId => {
            counts[typeId] = (counts[typeId] || 0) + 1;
          });
          const topId = Object.entries(counts).sort((a, b) => b[1] - a[1])[0][0];
          const type = scheduleTypes.find(item => item.id === topId);
          return type ? type.name : '';
        }

        function startOfWeek(date) {
          const d = normalizeDate(date);
          const day = (d.getDay() + 6) % 7;
          d.setDate(d.getDate() - day);
          return d;
        }

        function shiftDate(delta) {
          const d = normalizeDate(currentDate.value);
          d.setDate(d.getDate() + delta);
          currentDate.value = d;
        }

        function pickDate() {
          showPicker.value = true;
        }

        function confirmPicker() {
          const [y, m, d] = pickerValues.value;
          currentDate.value = new Date(y, m - 1, d);
          showPicker.value = false;
        }

        function goToday() {
          currentDate.value = normalizeDate(new Date());
        }

        function selectDay(date) {
          currentDate.value = normalizeDate(date);
          activeTab.value = 'today';
        }

        function shiftMonth(delta) {
          const next = new Date(year.value, month.value + delta, 1);
          year.value = next.getFullYear();
          month.value = next.getMonth();
        }

        function goMonth(monthIndex) {
          activeTab.value = 'month';
          month.value = monthIndex;
        }

        function getMonthDays(yearValue, monthIndex) {
          const daysInMonth = new Date(yearValue, monthIndex + 1, 0).getDate();
          const result = [];
          for (let day = 1; day <= daysInMonth; day++) {
            const date = new Date(yearValue, monthIndex, day);
            result.push({
              key: dateKey(date),
              label: `${monthIndex + 1}/${day}`,
              hours: getDayTotalHours(date),
              color: getDayTotalHours(date) ? dominantCellColor(date) : '#e2e8f0'
            });
          }
          return result;
        }

        function getMonthTotalHours(monthIndex) {
          return getMonthDays(year.value, monthIndex).reduce((sum, day) => sum + day.hours, 0);
        }

        function openTypeEditor() {
          activeTab.value = 'types';
        }

        function addType() {
          const palette = ['#06b6d4', '#84cc16', '#eab308', '#ec4899', '#14b8a6', '#6366f1'];
          const nextColor = palette[scheduleTypes.length % palette.length];
          scheduleTypes.push({
            id: createId('type'),
            name: `新类型 ${scheduleTypes.length + 1}`,
            color: nextColor
          });
        }

        function removeType(index) {
          const removedId = scheduleTypes[index].id;
          if (scheduleTypes.length <= 1) {
            vant.Toast('至少保留一个日程类型');
            return;
          }
          vant.Dialog.confirm({
            title: '删除类型',
            message: '删除后，该类型已涂色的小方块会自动清空。是否继续？'
          }).then(() => {
            scheduleTypes.splice(index, 1);
            Object.keys(dailyData).forEach(key => {
              const record = { ...dailyData[key] };
              Object.keys(record).forEach(hour => {
                if (record[hour] === removedId) delete record[hour];
              });
              setRecord(parseDateKey(key), record);
            });
            selectedType.value = scheduleTypes[0].id;
            vant.Toast('已删除类型');
          });
        }

        function openReset() {
          showReset.value = true;
        }

        function onResetAction(action) {
          showReset.value = false;
          if (!action || action.name === '取消') return;
          if (action.date === 'current') {
            vant.Dialog.confirm({
              title: '清空当前日期',
              message: `确定清空 ${formatDate(currentDate.value)} 的涂色记录吗？`
            }).then(() => {
              delete dailyData[dateKey(currentDate.value)];
              vant.Toast('已清空当前日期');
            });
          }
          if (action.date === 'all') {
            vant.Dialog.confirm({
              title: '清空全部数据',
              message: '此操作不可恢复，确定清空所有记录吗？'
            }).then(() => {
              Object.keys(dailyData).forEach(key => delete dailyData[key]);
              vant.Toast('已清空全部数据');
            });
          }
        }

        function isSameDate(a, b) {
          return dateKey(a) === dateKey(b);
        }

        return {
          activeTab,
          currentDate,
          selectedType,
          scheduleTypes,
          hours,
          showPicker,
          pickerValues,
          showReset,
          resetActions,
          year,
          month,
          today,
          weekNames,
          weekDays,
          weekRangeText,
          weekSegments,
          monthTitleText,
          monthCells,
          todaySegments,
          todayTotalHours,
          pad,
          formatDate,
          readableText,
          cellColor,
          toggleHour,
          pickDate,
          confirmPicker,
          shiftDate,
          goToday,
          getDaySegments,
          getDayTotalHours,
          dominantCellColor,
          topTypeName,
          selectDay,
          shiftMonth,
          goMonth,
          getMonthDays,
          getMonthTotalHours,
          openTypeEditor,
          addType,
          removeType,
          openReset,
          onResetAction,
          isSameDate
        };
      }
    }).use(vant).mount('#app');
  

Requests	IP Address	Location	AS Autonomous System
3	101.33.10.10	Frankfurt am Main, Hesse, Germany	AS139341ACE
2	104.26.2.143	United States	AS13335Cloudflare, Inc.
2	151.101.1.229	United States	AS54113Fastly, Inc.
7	3	-	-

Security Scan Report: dailycounter-dpndab0qqb72.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

Detected Technologies3

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