government public service

news media journalism

adult content

technology software

healthcare medical

English

Domain 'sorry-d2p.pages.dev' uses the developer-focused generic top-level domain (.dev), featuring subdomain 'sorry-d2p'. The core label 'pages' covers 5 characters holding two vowels versus three consonants. It segments into one word: pages. No strong language cues emerged from the frequency lists.

person

reason

context

html/b7/a7/b7a76a61-f6b6-4bfd-a79d-f9b7d73a1eb1.html.gz

2fc9b71e2fc8f54d991427214bfdea479918dbc74a695ac8edf571033acda3b1

d32533f952779eddfc6c1f2d7a532ab6f8f257a640196e6f14b4b51a297af049

7eb5bbf212f094215280d4991ae3c88824faf8abd478bb914344f4701a7edb5d

viewport

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


    /**
     * @typedef Apology
     * @type {object}
     * @property {number} id
     * @property {string} person
     * @property {string} reason
     * @property {string} context
     * @property {Date} date
     * @property {number} timestamp
     */

    class ApologyTracker {
        constructor() {

            /** @type {Apology[]}*/
            this.receivedApologies = [];
            /** @type {Apology[]}*/
            this.givenApologies = [];
            /** @type {'received' | 'given'} */
            this.currentTab = 'received';
            this.init();
        }

        init() {
            this.loadData();
            this.bindEvents();
            this.updateStats();
            this.renderApologies();
        }

        bindEvents() {
            receivedForm.addEventListener('submit', (e) => {
                e.preventDefault();
                this.addApology('received');
            });

            givenForm.addEventListener('submit', (e) => {
                e.preventDefault();
                this.addApology('given');
            });

            receivedTab.addEventListener('click', () => this.switchTab('received'));
            givenTab.addEventListener('click', () => this.switchTab('given'));

            importInput.addEventListener('change', (e) => this.importData(e));

            function saveDetailToggle(e) {
                if (typeof localStorage !== 'undefined') {
                    if (e.newState === "closed")  {
                        localStorage.setItem('detailsClosed', "true");
                    }
                    else localStorage.removeItem('detailsClosed');
                }

                if (e.newState === "closed")  {
                    receivedDetails.open = false;
                    givenDetails.open = false;
                } else if (e.newState === "open")  {
                    receivedDetails.open = true;
                    givenDetails.open = true;
                }

            }

            receivedDetails.addEventListener('toggle', saveDetailToggle)
            givenDetails.addEventListener('toggle', saveDetailToggle);
            searchQuery.addEventListener('input', () => {
                this.renderApologies()
                this.updateStats();
            });
        }

        switchTab(tab) {
            this.currentTab = tab;

            // Update tab buttons
            receivedTab.classList.toggle('active', tab === 'received');
            givenTab.classList.toggle('active', tab === 'given');

            // Update tab content
            receivedContent.classList.toggle('active', tab === 'received');
            givenContent.classList.toggle('active', tab === 'given');

            // Update stats label
            totalLabel.textContent = tab === 'received' ? 'Total Received' : 'Total Given';

            this.updateStats();
        }

        addApology(type) {
            const isReceived = type === 'received';
            const form = isReceived ? receivedForm : givenForm;
            const person = form.person.value;
            const reason = form.reason.value;
            const context = form.context.value;

            /** @type {Apology} */
            const apology = {
                id: Date.now(),
                person,
                reason,
                context,
                date: new Date(),
                timestamp: Date.now()
            };

            if (isReceived) {
                this.receivedApologies.unshift(apology);
            } else {
                this.givenApologies.unshift(apology);
            }

            this.saveData();
            this.updateStats();
            this.renderApologies();
            form.reset();
        }

        deleteApology(id, type) {
            if (type === 'received') {
                this.receivedApologies = this.receivedApologies.filter(apology => apology.id !== id);
            } else {
                this.givenApologies = this.givenApologies.filter(apology => apology.id !== id);
            }
            this.saveData();
            this.updateStats();
            this.renderApologies();
        }

        updateStats() {
            const apologies = this.filterApologies(this.currentTab === 'received' ? this.receivedApologies : this.givenApologies);
            const total = apologies.length;
            const now = new Date();
            const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);

            const thisWeekCount = apologies.filter(apology =>
                new Date(apology.date) >= weekAgo
            ).length;

            const daysSinceFirst = apologies.length > 0
                ? Math.max(1, Math.ceil((now - new Date(apologies[apologies.length - 1].date)) / (1000 * 60 * 60 * 24)))
                : 1;

            totalApologies.textContent = total;
            thisWeek.textContent = thisWeekCount;
            avgPerDay.textContent = total > 0 ? (total / daysSinceFirst).toFixed(1) : 0;
        }

        /**
         * @param {Apology[]} apologies
         * @return {Apology[]}
         **/
        filterApologies(apologies) {
            if (searchQuery.value && typeof searchQuery.value === 'string') {
                const normalized_query = searchQuery.value.normalize().toLowerCase();
                return apologies.filter(apology => {
                    const normalized_name = apology.person.normalize().toLowerCase();
                    return normalized_name.includes(normalized_query);
                })
            } else return apologies;
        }

        renderApologies() {
            const isReceived = this.currentTab === 'received';
            const unfilteredApologies = isReceived ? this.receivedApologies : this.givenApologies;
            const apologies = this.filterApologies(unfilteredApologies);
            const container = isReceived ? receivedList : givenList;


            if (unfilteredApologies.length === 0) {
                const emptyMessage = isReceived
                    ? 'No apologies received yet!<br>When someone apologizes to you, add it above to start tracking.'
                    : 'No apologies given yet!<br>When you apologize to someone, add it above to start tracking.';

                container.innerHTML = `
                        <div class="empty-state">
                            <h3>${emptyMessage.split('<br>')[0]}</h3>
                            <p>${emptyMessage.split('<br>')[1]}</p>
                        </div>
                    `;
                return;
            }

            if (unfilteredApologies.length !== 0 && apologies.length === 0) {
                const emptyMessage = 'No apologies matched your filter!<br>Try change your search query';

                container.innerHTML = `
                        <div class="empty-state">
                            <h3>${emptyMessage.split('<br>')[0]}</h3>
                            <p>${emptyMessage.split('<br>')[1]}</p>
                        </div>
                    `;
                return;
            }

            const actionText = isReceived ? 'Apologized for' : 'You apologized for';
            container.innerHTML = apologies.map(apology => `
                    <div class="apology-item">
                        <div class="apology-header">
                            <span class="apology-person">${apology.person}</span>
                            <div>
                                <span class="apology-date">${this.formatDate(apology.date)}</span>
                                <button class="delete-btn" onclick="tracker.deleteApology(${apology.id}, '${this.currentTab}')">×</button>
                            </div>
                        </div>
                        <div class="apology-reason">${actionText}: ${apology.reason}</div>
                        ${apology.context ? `<div class="apology-context">"${apology.context}"</div>` : ''}
                    </div>
                `).join('');
        }

        formatDate(date) {
            const d = new Date(date);
            const now = new Date();
            const diffTime = Math.abs(now - d);
            const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));

            if (diffDays === 0) {
                return 'Today';
            } else if (diffDays === 1) {
                return 'Yesterday';
            } else if (diffDays < 7) {
                return `${diffDays} days ago`;
            } else {
                return d.toLocaleDateString();
            }
        }

        saveData() {
            if (typeof localStorage !== 'undefined') {
                const data = {
                    receivedApologies: this.receivedApologies,
                    givenApologies: this.givenApologies
                };
                localStorage.setItem('apologyTracker', JSON.stringify(data));
            }
        }

        loadData() {
            if (typeof localStorage !== 'undefined') {
                const saved = localStorage.getItem('apologyTracker');
                if (saved) {
                    try {
                        const data = JSON.parse(saved);
                        this.receivedApologies = data.receivedApologies || [];
                        this.givenApologies = data.givenApologies || [];

                        // Convert date strings back to Date objects
                        this.receivedApologies.forEach(apology => {
                            apology.date = new Date(apology.date);
                        });
                        this.givenApologies.forEach(apology => {
                            apology.date = new Date(apology.date);
                        });
                    } catch (error) {
                        console.error('Failed to load saved data:', error);
                    }
                }
                if (localStorage.getItem('detailsClosed')) {
                    receivedDetails.open = false;
                    givenDetails.open = false;
                }
            }
        }

        exportData() {
            const data = {
                receivedApologies: this.receivedApologies,
                givenApologies: this.givenApologies,
                exportDate: new Date().toISOString()
            };

            const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
            const url = URL.createObjectURL(blob);

            const a = document.createElement('a');
            a.href = url;
            a.download = `apology-tracker-${new Date().toISOString().split('T')[0]}.json`;
            document.body.appendChild(a);
            a.click();
            document.body.removeChild(a);
            URL.revokeObjectURL(url);
        }

        importData(event) {
            const file = event.target.files[0];
            if (!file) return;

            const reader = new FileReader();
            reader.onload = (e) => {
                try {
                    const data = JSON.parse(e.target.result);

                    if (data.receivedApologies || data.givenApologies) {
                        const confirmed = confirm('This will replace all current data. Are you sure?');
                        if (confirmed) {
                            this.receivedApologies = (data.receivedApologies || []).map(apology => ({
                                ...apology,
                                date: new Date(apology.date)
                            }));
                            this.givenApologies = (data.givenApologies || []).map(apology => ({
                                ...apology,
                                date: new Date(apology.date)
                            }));

                            this.saveData();
                            this.updateStats();
                            this.renderApologies();
                            alert('Data imported successfully!');
                        }
                    } else {
                        alert('Invalid file format. Please select a valid apology tracker export file.');
                    }
                } catch (error) {
                    alert('Failed to import data. Please check the file format.');
                    console.error('Import error:', error);
                }
            };
            reader.readAsText(file);

            // Clear the input so the same file can be selected again
            event.target.value = '';
        }
    }

    const tracker = new ApologyTracker();



    if ('serviceWorker' in navigator) {
        navigator.serviceWorker.register('/service-worker.js')
    }


Requests	IP Address	Location	AS Autonomous System
2	172.66.47.157	United States	AS13335Cloudflare, Inc.
2	1	-	-

Security Scan Report: sorry-d2p.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 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