comparing 43dc59358d344dd3ab84011dd1e2b6f8e56f5569 and main on dunkirk.sh/bunplayground

.data/tokensList.json

···

       1
       1
       +
       {"0c75ba92a404b78b7a47c5e7f7c0445a2c9b4da3710abbd8c86626a5a872914ef5ff3765e0c01e26a627f3a266ceed4dbe79b38d9550c857328dcb1a0729d389c9818bf66456bc2a468851134f0ff2a0c94693aa7a7bc27a79bd5daf6bfb5b7dd950ea0e457b7e117b92fbe586789b66c6369c0bf4343fc35f2d1bebf4253106647363dd946ce6c08000230073cdb1fabafd41cd6b3980826e0f6d5cef56dec0":1748872876777}

.gitignore

···

       32
       32
        
       

     

       33
       33
        
       # Finder (MacOS) folder config

     

       34
       34
        
       .DS_Store

     

       35
       35
       +
       .data

+29

amazon-shortener.user.js

···

       1
       1
       +
       // ==UserScript==

     

       2
       2
       +
       // @name         Amazon URL Cleaner

     

       3
       3
       +
       // @namespace    https://tangled.sh/@dunkirk.sh/bunplayground/amazon-shortener

     

       4
       4
       +
       // @version      0.1

     

       5
       5
       +
       // @description  Removes fluff from Amazon URLs to get clean product links

     

       6
       6
       +
       // @author       You

     

       7
       7
       +
       // @match        https://www.amazon.com/*

     

       8
       8
       +
       // @grant        none

     

       9
       9
       +
       // @run-at       document-start

     

       10
       10
       +
       // ==/UserScript==

     

       11
       11
       +
       

     

       12
       12
       +
       (() => {

     

       13
       13
       +
         function cleanURL() {

     

       14
       14
       +
           const url = window.location.href;

     

       15
       15
       +
           const match = url.match(/amazon\.com.*?\/([A-Z0-9]{10})/);

     

       16
       16
       +
           if (match) {

     

       17
       17
       +
             const asin = match[1];

     

       18
       18
       +
             const clean = `https://www.amazon.com/dp/${asin}`;

     

       19
       19
       +
             if (url !== clean) {

     

       20
       20
       +
               window.history.replaceState(null, "", clean);

     

       21
       21
       +
             }

     

       22
       22
       +
           }

     

       23
       23
       +
         }

     

       24
       24
       +
       

     

       25
       25
       +
         cleanURL();

     

       26
       26
       +
       

     

       27
       27
       +
         window.addEventListener("locationchange", cleanURL);

     

       28
       28
       +
         window.addEventListener("popstate", cleanURL);

     

       29
       29
       +
       })();

bigboy.gz

This is a binary file and will not be displayed.

-867

bluesky-community-verifications.js

···

       1
       1
       -
       (() => {

     

       2
       2
       -
         // Script has already been initialized check

     

       3
       3
       -
         if (window.bskyTrustedUsersInitialized) {

     

       4
       4
       -
           console.log("Trusted Users script already initialized");

     

       5
       5
       -
           return;

     

       6
       6
       -
         }

     

       7
       7
       -
       

     

       8
       8
       -
         // Mark script as initialized

     

       9
       9
       -
         window.bskyTrustedUsersInitialized = true;

     

       10
       10
       -
       

     

       11
       11
       -
         // Define storage keys

     

       12
       12
       -
         const TRUSTED_USERS_STORAGE_KEY = "bsky_trusted_users";

     

       13
       13
       -
         const VERIFICATION_CACHE_STORAGE_KEY = "bsky_verification_cache";

     

       14
       14
       -
         const CACHE_EXPIRY_TIME = 24 * 60 * 60 * 1000; // 24 hours

     

       15
       15
       -
       

     

       16
       16
       -
         // Function to get trusted users from local storage

     

       17
       17
       -
         const getTrustedUsers = () => {

     

       18
       18
       -
           const storedUsers = localStorage.getItem(TRUSTED_USERS_STORAGE_KEY);

     

       19
       19
       -
           return storedUsers ? JSON.parse(storedUsers) : [];

     

       20
       20
       -
         };

     

       21
       21
       -
       

     

       22
       22
       -
         // Function to save trusted users to local storage

     

       23
       23
       -
         const saveTrustedUsers = (users) => {

     

       24
       24
       -
           localStorage.setItem(TRUSTED_USERS_STORAGE_KEY, JSON.stringify(users));

     

       25
       25
       -
         };

     

       26
       26
       -
       

     

       27
       27
       -
         // Function to add a trusted user

     

       28
       28
       -
         const addTrustedUser = (handle) => {

     

       29
       29
       -
           const users = getTrustedUsers();

     

       30
       30
       -
           if (!users.includes(handle)) {

     

       31
       31
       -
             users.push(handle);

     

       32
       32
       -
             saveTrustedUsers(users);

     

       33
       33
       -
           }

     

       34
       34
       -
         };

     

       35
       35
       -
       

     

       36
       36
       -
         // Function to remove a trusted user

     

       37
       37
       -
         const removeTrustedUser = (handle) => {

     

       38
       38
       -
           const users = getTrustedUsers();

     

       39
       39
       -
           const updatedUsers = users.filter((user) => user !== handle);

     

       40
       40
       -
           saveTrustedUsers(updatedUsers);

     

       41
       41
       -
         };

     

       42
       42
       -
       

     

       43
       43
       -
         // Cache functions

     

       44
       44
       -
         const getVerificationCache = () => {

     

       45
       45
       -
           const cache = localStorage.getItem(VERIFICATION_CACHE_STORAGE_KEY);

     

       46
       46
       -
           return cache ? JSON.parse(cache) : {};

     

       47
       47
       -
         };

     

       48
       48
       -
       

     

       49
       49
       -
         const saveVerificationCache = (cache) => {

     

       50
       50
       -
           localStorage.setItem(VERIFICATION_CACHE_STORAGE_KEY, JSON.stringify(cache));

     

       51
       51
       -
         };

     

       52
       52
       -
       

     

       53
       53
       -
         const getCachedVerifications = (user) => {

     

       54
       54
       -
           const cache = getVerificationCache();

     

       55
       55
       -
           return cache[user] || null;

     

       56
       56
       -
         };

     

       57
       57
       -
       

     

       58
       58
       -
         const cacheVerifications = (user, records) => {

     

       59
       59
       -
           const cache = getVerificationCache();

     

       60
       60
       -
           cache[user] = {

     

       61
       61
       -
             records,

     

       62
       62
       -
             timestamp: Date.now(),

     

       63
       63
       -
           };

     

       64
       64
       -
           saveVerificationCache(cache);

     

       65
       65
       -
         };

     

       66
       66
       -
       

     

       67
       67
       -
         const isCacheValid = (cacheEntry) => {

     

       68
       68
       -
           return cacheEntry && Date.now() - cacheEntry.timestamp < CACHE_EXPIRY_TIME;

     

       69
       69
       -
         };

     

       70
       70
       -
       

     

       71
       71
       -
         // Function to remove a specific user from the verification cache

     

       72
       72
       -
         const removeUserFromCache = (handle) => {

     

       73
       73
       -
           const cache = getVerificationCache();

     

       74
       74
       -
           if (cache[handle]) {

     

       75
       75
       -
             delete cache[handle];

     

       76
       76
       -
             saveVerificationCache(cache);

     

       77
       77
       -
             console.log(`Removed ${handle} from verification cache`);

     

       78
       78
       -
           }

     

       79
       79
       -
         };

     

       80
       80
       -
       

     

       81
       81
       -
         const clearCache = () => {

     

       82
       82
       -
           localStorage.removeItem(VERIFICATION_CACHE_STORAGE_KEY);

     

       83
       83
       -
           console.log("Verification cache cleared");

     

       84
       84
       -
         };

     

       85
       85
       -
       

     

       86
       86
       -
         // Store all verifiers for a profile

     

       87
       87
       -
         let profileVerifiers = [];

     

       88
       88
       -
       

     

       89
       89
       -
         // Store current profile DID

     

       90
       90
       -
         let currentProfileDid = null;

     

       91
       91
       -
       

     

       92
       92
       -
         // Function to check if a trusted user has verified the current profile

     

       93
       93
       -
         const checkTrustedUserVerifications = async (profileDid) => {

     

       94
       94
       -
           currentProfileDid = profileDid; // Store for recheck functionality

     

       95
       95
       -
           const trustedUsers = getTrustedUsers();

     

       96
       96
       -
           profileVerifiers = []; // Reset the verifiers list

     

       97
       97
       -
       

     

       98
       98
       -
           if (trustedUsers.length === 0) {

     

       99
       99
       -
             console.log("No trusted users to check for verifications");

     

       100
       100
       -
             return false;

     

       101
       101
       -
           }

     

       102
       102
       -
       

     

       103
       103
       -
           console.log(`Checking if any trusted users have verified ${profileDid}`);

     

       104
       104
       -
       

     

       105
       105
       -
           // Use Promise.all to fetch all verification data in parallel

     

       106
       106
       -
           const verificationPromises = trustedUsers.map(async (trustedUser) => {

     

       107
       107
       -
             try {

     

       108
       108
       -
               // Helper function to fetch all verification records with pagination

     

       109
       109
       -
               const fetchAllVerifications = async (user) => {

     

       110
       110
       -
                 // Check cache first

     

       111
       111
       -
                 const cachedData = getCachedVerifications(user);

     

       112
       112
       -
                 if (cachedData && isCacheValid(cachedData)) {

     

       113
       113
       -
                   console.log(`Using cached verification data for ${user}`);

     

       114
       114
       -
                   return cachedData.records;

     

       115
       115
       -
                 }

     

       116
       116
       -
       

     

       117
       117
       -
                 console.log(`Fetching fresh verification data for ${user}`);

     

       118
       118
       -
                 let allRecords = [];

     

       119
       119
       -
                 let cursor = null;

     

       120
       120
       -
                 let hasMore = true;

     

       121
       121
       -
       

     

       122
       122
       -
                 while (hasMore) {

     

       123
       123
       -
                   const url = cursor

     

       124
       124
       -
                     ? `https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=${user}&collection=app.bsky.graph.verification&cursor=${cursor}`

     

       125
       125
       -
                     : `https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=${user}&collection=app.bsky.graph.verification`;

     

       126
       126
       -
       

     

       127
       127
       -
                   const response = await fetch(url);

     

       128
       128
       -
                   const data = await response.json();

     

       129
       129
       -
       

     

       130
       130
       -
                   if (data.records && data.records.length > 0) {

     

       131
       131
       -
                     allRecords = [...allRecords, ...data.records];

     

       132
       132
       -
                   }

     

       133
       133
       -
       

     

       134
       134
       -
                   if (data.cursor) {

     

       135
       135
       -
                     cursor = data.cursor;

     

       136
       136
       -
                   } else {

     

       137
       137
       -
                     hasMore = false;

     

       138
       138
       -
                   }

     

       139
       139
       -
                 }

     

       140
       140
       -
       

     

       141
       141
       -
                 // Save to cache

     

       142
       142
       -
                 cacheVerifications(user, allRecords);

     

       143
       143
       -
                 return allRecords;

     

       144
       144
       -
               };

     

       145
       145
       -
       

     

       146
       146
       -
               // Fetch all verification records for this trusted user

     

       147
       147
       -
               const records = await fetchAllVerifications(trustedUser);

     

       148
       148
       -
       

     

       149
       149
       -
               console.log(`Received verification data from ${trustedUser}`, {

     

       150
       150
       -
                 records,

     

       151
       151
       -
               });

     

       152
       152
       -
       

     

       153
       153
       -
               // Check if this trusted user has verified the current profile

     

       154
       154
       -
               if (records.length > 0) {

     

       155
       155
       -
                 for (const record of records) {

     

       156
       156
       -
                   if (record.value && record.value.subject === profileDid) {

     

       157
       157
       -
                     console.log(

     

       158
       158
       -
                       `${profileDid} is verified by trusted user ${trustedUser}`,

     

       159
       159
       -
                     );

     

       160
       160
       -
       

     

       161
       161
       -
                     // Add to verifiers list

     

       162
       162
       -
                     profileVerifiers.push(trustedUser);

     

       163
       163
       -
                     break; // Once we find a verification, we can stop checking

     

       164
       164
       -
                   }

     

       165
       165
       -
                 }

     

       166
       166
       -
               }

     

       167
       167
       -
               return { trustedUser, success: true };

     

       168
       168
       -
             } catch (error) {

     

       169
       169
       -
               console.error(

     

       170
       170
       -
                 `Error checking verifications from ${trustedUser}:`,

     

       171
       171
       -
                 error,

     

       172
       172
       -
               );

     

       173
       173
       -
               return { trustedUser, success: false, error };

     

       174
       174
       -
             }

     

       175
       175
       -
           });

     

       176
       176
       -
       

     

       177
       177
       -
           // Wait for all verification checks to complete

     

       178
       178
       -
           const results = await Promise.all(verificationPromises);

     

       179
       179
       -
       

     

       180
       180
       -
           // Log summary of API calls

     

       181
       181
       -
           console.log(`API calls completed: ${results.length}`);

     

       182
       182
       -
           console.log(`Successful calls: ${results.filter((r) => r.success).length}`);

     

       183
       183
       -
           console.log(`Failed calls: ${results.filter((r) => !r.success).length}`);

     

       184
       184
       -
       

     

       185
       185
       -
           // If we have verifiers, display the badge

     

       186
       186
       -
           if (profileVerifiers.length > 0) {

     

       187
       187
       -
             displayVerificationBadge(profileVerifiers);

     

       188
       188
       -
             return true;

     

       189
       189
       -
           }

     

       190
       190
       -
       

     

       191
       191
       -
           console.log(`${profileDid} is not verified by any trusted users`);

     

       192
       192
       -
       

     

       193
       193
       -
           // Add recheck button even when no verifications are found

     

       194
       194
       -
           createPillButtons();

     

       195
       195
       -
       

     

       196
       196
       -
           return false;

     

       197
       197
       -
         };

     

       198
       198
       -
       

     

       199
       199
       -
         // Function to create a pill with recheck and settings buttons

     

       200
       200
       -
         const createPillButtons = () => {

     

       201
       201
       -
           // Remove existing buttons if any

     

       202
       202
       -
           const existingPill = document.getElementById(

     

       203
       203
       -
             "trusted-users-pill-container",

     

       204
       204
       -
           );

     

       205
       205
       -
           if (existingPill) {

     

       206
       206
       -
             existingPill.remove();

     

       207
       207
       -
           }

     

       208
       208
       -
       

     

       209
       209
       -
           // Create pill container

     

       210
       210
       -
           const pillContainer = document.createElement("div");

     

       211
       211
       -
           pillContainer.id = "trusted-users-pill-container";

     

       212
       212
       -
           pillContainer.style.cssText = `

     

       213
       213
       -
             position: fixed;

     

       214
       214
       -
             bottom: 20px;

     

       215
       215
       -
             right: 20px;

     

       216
       216
       -
             z-index: 10000;

     

       217
       217
       -
             display: flex;

     

       218
       218
       -
             border-radius: 20px;

     

       219
       219
       -
             overflow: hidden;

     

       220
       220
       -
             box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);

     

       221
       221
       -
           `;

     

       222
       222
       -
       

     

       223
       223
       -
           // Create recheck button (left half of pill)

     

       224
       224
       -
           const recheckButton = document.createElement("button");

     

       225
       225
       -
           recheckButton.id = "trusted-users-recheck-button";

     

       226
       226
       -
           recheckButton.innerHTML = "↻ Recheck";

     

       227
       227
       -
           recheckButton.style.cssText = `

     

       228
       228
       -
             padding: 10px 15px;

     

       229
       229
       -
             background-color: #2D578D;

     

       230
       230
       -
             color: white;

     

       231
       231
       -
             border: none;

     

       232
       232
       -
             cursor: pointer;

     

       233
       233
       -
             font-weight: bold;

     

       234
       234
       -
             border-top-left-radius: 20px;

     

       235
       235
       -
             border-bottom-left-radius: 20px;

     

       236
       236
       -
           `;

     

       237
       237
       -
       

     

       238
       238
       -
           // Add click event to recheck

     

       239
       239
       -
           recheckButton.addEventListener("click", async () => {

     

       240
       240
       -
             if (currentProfileDid) {

     

       241
       241
       -
               // Remove any existing badges when rechecking

     

       242
       242
       -
               const existingBadge = document.getElementById(

     

       243
       243
       -
                 "user-trusted-verification-badge",

     

       244
       244
       -
               );

     

       245
       245
       -
               if (existingBadge) {

     

       246
       246
       -
                 existingBadge.remove();

     

       247
       247
       -
               }

     

       248
       248
       -
       

     

       249
       249
       -
               // Show loading state

     

       250
       250
       -
               recheckButton.innerHTML = "⟳ Checking...";

     

       251
       251
       -
               recheckButton.disabled = true;

     

       252
       252
       -
       

     

       253
       253
       -
               // Recheck verifications

     

       254
       254
       -
               await checkTrustedUserVerifications(currentProfileDid);

     

       255
       255
       -
       

     

       256
       256
       -
               // Reset button

     

       257
       257
       -
               recheckButton.innerHTML = "↻ Recheck";

     

       258
       258
       -
               recheckButton.disabled = false;

     

       259
       259
       -
             }

     

       260
       260
       -
           });

     

       261
       261
       -
       

     

       262
       262
       -
           // Create vertical divider

     

       263
       263
       -
           const divider = document.createElement("div");

     

       264
       264
       -
           divider.style.cssText = `

     

       265
       265
       -
             width: 1px;

     

       266
       266
       -
             background-color: rgba(255, 255, 255, 0.3);

     

       267
       267
       -
           `;

     

       268
       268
       -
       

     

       269
       269
       -
           // Create settings button (right half of pill)

     

       270
       270
       -
           const settingsButton = document.createElement("button");

     

       271
       271
       -
           settingsButton.id = "bsky-trusted-settings-button";

     

       272
       272
       -
           settingsButton.textContent = "Settings";

     

       273
       273
       -
           settingsButton.style.cssText = `

     

       274
       274
       -
             padding: 10px 15px;

     

       275
       275
       -
             background-color: #2D578D;

     

       276
       276
       -
             color: white;

     

       277
       277
       -
             border: none;

     

       278
       278
       -
             cursor: pointer;

     

       279
       279
       -
             font-weight: bold;

     

       280
       280
       -
             border-top-right-radius: 20px;

     

       281
       281
       -
             border-bottom-right-radius: 20px;

     

       282
       282
       -
           `;

     

       283
       283
       -
       

     

       284
       284
       -
           // Add elements to pill

     

       285
       285
       -
           pillContainer.appendChild(recheckButton);

     

       286
       286
       -
           pillContainer.appendChild(divider);

     

       287
       287
       -
           pillContainer.appendChild(settingsButton);

     

       288
       288
       -
       

     

       289
       289
       -
           // Add pill to page

     

       290
       290
       -
           document.body.appendChild(pillContainer);

     

       291
       291
       -
       

     

       292
       292
       -
           // Add event listener to settings button

     

       293
       293
       -
           settingsButton.addEventListener("click", () => {

     

       294
       294
       -
             if (settingsModal) {

     

       295
       295
       -
               settingsModal.style.display = "flex";

     

       296
       296
       -
               updateTrustedUsersList();

     

       297
       297
       -
             } else {

     

       298
       298
       -
               createSettingsModal();

     

       299
       299
       -
             }

     

       300
       300
       -
           });

     

       301
       301
       -
         };

     

       302
       302
       -
       

     

       303
       303
       -
         // Function to display verification badge on the profile

     

       304
       304
       -
         const displayVerificationBadge = (verifierHandles) => {

     

       305
       305
       -
           // Find the profile header or name element to add the badge to

     

       306
       306
       -
           const nameElements = document.querySelectorAll(

     

       307
       307
       -
             '[data-testid="profileHeaderDisplayName"]',

     

       308
       308
       -
           );

     

       309
       309
       -
           const nameElement = nameElements[nameElements.length - 1];

     

       310
       310
       -
       

     

       311
       311
       -
           console.log(nameElement);

     

       312
       312
       -
       

     

       313
       313
       -
           if (nameElement) {

     

       314
       314
       -
             // Remove existing badge if present

     

       315
       315
       -
             const existingBadge = document.getElementById(

     

       316
       316
       -
               "user-trusted-verification-badge",

     

       317
       317
       -
             );

     

       318
       318
       -
             if (existingBadge) {

     

       319
       319
       -
               existingBadge.remove();

     

       320
       320
       -
             }

     

       321
       321
       -
       

     

       322
       322
       -
             const badge = document.createElement("span");

     

       323
       323
       -
             badge.id = "user-trusted-verification-badge";

     

       324
       324
       -
             badge.innerHTML = "✓";

     

       325
       325
       -
       

     

       326
       326
       -
             // Create tooltip text with all verifiers

     

       327
       327
       -
             const verifiersText =

     

       328
       328
       -
               verifierHandles.length > 1

     

       329
       329
       -
                 ? `Verified by: ${verifierHandles.join(", ")}`

     

       330
       330
       -
                 : `Verified by ${verifierHandles[0]}`;

     

       331
       331
       -
       

     

       332
       332
       -
             badge.title = verifiersText;

     

       333
       333
       -
             badge.style.cssText = `

     

       334
       334
       -
               background-color: #0070ff;

     

       335
       335
       -
               color: white;

     

       336
       336
       -
               border-radius: 50%;

     

       337
       337
       -
               width: 18px;

     

       338
       338
       -
               height: 18px;

     

       339
       339
       -
               margin-left: 8px;

     

       340
       340
       -
               font-size: 12px;

     

       341
       341
       -
               font-weight: bold;

     

       342
       342
       -
               cursor: help;

     

       343
       343
       -
               display: inline-flex;

     

       344
       344
       -
               align-items: center;

     

       345
       345
       -
               justify-content: center;

     

       346
       346
       -
             `;

     

       347
       347
       -
       

     

       348
       348
       -
             // Add a click event to show all verifiers

     

       349
       349
       -
             badge.addEventListener("click", (e) => {

     

       350
       350
       -
               e.stopPropagation();

     

       351
       351
       -
               showVerifiersPopup(verifierHandles);

     

       352
       352
       -
             });

     

       353
       353
       -
       

     

       354
       354
       -
             nameElement.appendChild(badge);

     

       355
       355
       -
           }

     

       356
       356
       -
       

     

       357
       357
       -
           // Also add pill buttons when verification is found

     

       358
       358
       -
           createPillButtons();

     

       359
       359
       -
         };

     

       360
       360
       -
       

     

       361
       361
       -
         // Function to show a popup with all verifiers

     

       362
       362
       -
         const showVerifiersPopup = (verifierHandles) => {

     

       363
       363
       -
           // Remove existing popup if any

     

       364
       364
       -
           const existingPopup = document.getElementById("verifiers-popup");

     

       365
       365
       -
           if (existingPopup) {

     

       366
       366
       -
             existingPopup.remove();

     

       367
       367
       -
           }

     

       368
       368
       -
       

     

       369
       369
       -
           // Create popup

     

       370
       370
       -
           const popup = document.createElement("div");

     

       371
       371
       -
           popup.id = "verifiers-popup";

     

       372
       372
       -
           popup.style.cssText = `

     

       373
       373
       -
             position: fixed;

     

       374
       374
       -
             top: 50%;

     

       375
       375
       -
             left: 50%;

     

       376
       376
       -
             transform: translate(-50%, -50%);

     

       377
       377
       -
             background-color: #24273A;

     

       378
       378
       -
             padding: 20px;

     

       379
       379
       -
             border-radius: 10px;

     

       380
       380
       -
             z-index: 10002;

     

       381
       381
       -
             box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);

     

       382
       382
       -
             max-width: 400px;

     

       383
       383
       -
             width: 90%;

     

       384
       384
       -
           `;

     

       385
       385
       -
       

     

       386
       386
       -
           // Create popup content

     

       387
       387
       -
           popup.innerHTML = `

     

       388
       388
       -
             <h3 style="margin-top: 0; color: white;">Profile Verifiers</h3>

     

       389
       389
       -
             <div style="max-height: 300px; overflow-y: auto;">

     

       390
       390
       -
               ${verifierHandles

     

       391
       391
       -
                 .map(

     

       392
       392
       -
                   (handle) => `

     

       393
       393
       -
                 <div style="padding: 8px 0; border-bottom: 1px solid #444; color: white;">

     

       394
       394
       -
                   ${handle}

     

       395
       395
       -
                 </div>

     

       396
       396
       -
               `,

     

       397
       397
       -
                 )

     

       398
       398
       -
                 .join("")}

     

       399
       399
       -
             </div>

     

       400
       400
       -
             <button id="close-verifiers-popup" style="

     

       401
       401
       -
               margin-top: 15px;

     

       402
       402
       -
               padding: 8px 15px;

     

       403
       403
       -
               background-color: #473A3A;

     

       404
       404
       -
               color: white;

     

       405
       405
       -
               border: none;

     

       406
       406
       -
               border-radius: 4px;

     

       407
       407
       -
               cursor: pointer;

     

       408
       408
       -
             ">Close</button>

     

       409
       409
       -
           `;

     

       410
       410
       -
       

     

       411
       411
       -
           // Add to body

     

       412
       412
       -
           document.body.appendChild(popup);

     

       413
       413
       -
       

     

       414
       414
       -
           // Add close handler

     

       415
       415
       -
           document

     

       416
       416
       -
             .getElementById("close-verifiers-popup")

     

       417
       417
       -
             .addEventListener("click", () => {

     

       418
       418
       -
               popup.remove();

     

       419
       419
       -
             });

     

       420
       420
       -
       

     

       421
       421
       -
           // Close when clicking outside

     

       422
       422
       -
           document.addEventListener("click", function closePopup(e) {

     

       423
       423
       -
             if (!popup.contains(e.target)) {

     

       424
       424
       -
               popup.remove();

     

       425
       425
       -
               document.removeEventListener("click", closePopup);

     

       426
       426
       -
             }

     

       427
       427
       -
           });

     

       428
       428
       -
         };

     

       429
       429
       -
       

     

       430
       430
       -
         // Create settings modal

     

       431
       431
       -
         let settingsModal = null;

     

       432
       432
       -
       

     

       433
       433
       -
         // Function to update the list of trusted users in the UI

     

       434
       434
       -
         const updateTrustedUsersList = () => {

     

       435
       435
       -
           const trustedUsersList = document.getElementById("trustedUsersList");

     

       436
       436
       -
           if (!trustedUsersList) return;

     

       437
       437
       -
       

     

       438
       438
       -
           const users = getTrustedUsers();

     

       439
       439
       -
           trustedUsersList.innerHTML = "";

     

       440
       440
       -
       

     

       441
       441
       -
           if (users.length === 0) {

     

       442
       442
       -
             trustedUsersList.innerHTML = "<p>No trusted users added yet.</p>";

     

       443
       443
       -
             return;

     

       444
       444
       -
           }

     

       445
       445
       -
       

     

       446
       446
       -
           for (const user of users) {

     

       447
       447
       -
             const userItem = document.createElement("div");

     

       448
       448
       -
             userItem.style.cssText = `

     

       449
       449
       -
               display: flex;

     

       450
       450
       -
               justify-content: space-between;

     

       451
       451
       -
               align-items: center;

     

       452
       452
       -
               padding: 8px 0;

     

       453
       453
       -
               border-bottom: 1px solid #eee;

     

       454
       454
       -
             `;

     

       455
       455
       -
       

     

       456
       456
       -
             userItem.innerHTML = `

     

       457
       457
       -
               <span>${user}</span>

     

       458
       458
       -
               <button class="remove-user" data-handle="${user}" style="background-color: #CE3838; color: white; border: none; border-radius: 4px; padding: 5px 10px; cursor: pointer;">Remove</button>

     

       459
       459
       -
             `;

     

       460
       460
       -
       

     

       461
       461
       -
             trustedUsersList.appendChild(userItem);

     

       462
       462
       -
           }

     

       463
       463
       -
       

     

       464
       464
       -
           // Add event listeners to remove buttons

     

       465
       465
       -
           const removeButtons = document.querySelectorAll(".remove-user");

     

       466
       466
       -
           for (const btn of removeButtons) {

     

       467
       467
       -
             btn.addEventListener("click", (e) => {

     

       468
       468
       -
               const handle = e.target.getAttribute("data-handle");

     

       469
       469
       -
               removeTrustedUser(handle);

     

       470
       470
       -
               removeUserFromCache(handle);

     

       471
       471
       -
               updateTrustedUsersList();

     

       472
       472
       -
             });

     

       473
       473
       -
           }

     

       474
       474
       -
         };

     

       475
       475
       -
       

     

       476
       476
       -
         const searchUsers = async (searchQuery) => {

     

       477
       477
       -
           if (!searchQuery || searchQuery.length < 2) return [];

     

       478
       478
       -
       

     

       479
       479
       -
           try {

     

       480
       480
       -
             const response = await fetch(

     

       481
       481
       -
               `https://public.api.bsky.app/xrpc/app.bsky.actor.searchActors?term=${encodeURIComponent(searchQuery)}&limit=5`,

     

       482
       482
       -
             );

     

       483
       483
       -
             const data = await response.json();

     

       484
       484
       -
             return data.actors || [];

     

       485
       485
       -
           } catch (error) {

     

       486
       486
       -
             console.error("Error searching for users:", error);

     

       487
       487
       -
             return [];

     

       488
       488
       -
           }

     

       489
       489
       -
         };

     

       490
       490
       -
       

     

       491
       491
       -
         // Function to create and show the autocomplete dropdown

     

       492
       492
       -
         const showAutocompleteResults = (results, inputElement) => {

     

       493
       493
       -
           // Remove existing dropdown if any

     

       494
       494
       -
           const existingDropdown = document.getElementById("autocomplete-dropdown");

     

       495
       495
       -
           if (existingDropdown) existingDropdown.remove();

     

       496
       496
       -
       

     

       497
       497
       -
           if (results.length === 0) return;

     

       498
       498
       -
       

     

       499
       499
       -
           // Create dropdown

     

       500
       500
       -
           const dropdown = document.createElement("div");

     

       501
       501
       -
           dropdown.id = "autocomplete-dropdown";

     

       502
       502
       -
           dropdown.style.cssText = `

     

       503
       503
       -
             position: absolute;

     

       504
       504
       -
             background-color: #2A2E3D;

     

       505
       505
       -
             border: 1px solid #444;

     

       506
       506
       -
             border-radius: 4px;

     

       507
       507
       -
             box-shadow: 0 4px 8px rgba(0,0,0,0.2);

     

       508
       508
       -
             max-height: 300px;

     

       509
       509
       -
             overflow-y: auto;

     

       510
       510
       -
             width: ${inputElement.offsetWidth}px;

     

       511
       511
       -
             z-index: 10002;

     

       512
       512
       -
             margin-top: 2px;

     

       513
       513
       -
           `;

     

       514
       514
       -
       

     

       515
       515
       -
           // Position dropdown below input

     

       516
       516
       -
           const inputRect = inputElement.getBoundingClientRect();

     

       517
       517
       -
           dropdown.style.left = `${inputRect.left}px`;

     

       518
       518
       -
           dropdown.style.top = `${inputRect.bottom}px`;

     

       519
       519
       -
       

     

       520
       520
       -
           // Add results to dropdown

     

       521
       521
       -
           for (const user of results) {

     

       522
       522
       -
             const userItem = document.createElement("div");

     

       523
       523
       -
             userItem.className = "autocomplete-item";

     

       524
       524
       -
             userItem.style.cssText = `

     

       525
       525
       -
               display: flex;

     

       526
       526
       -
               align-items: center;

     

       527
       527
       -
               padding: 8px 12px;

     

       528
       528
       -
               cursor: pointer;

     

       529
       529
       -
               color: white;

     

       530
       530
       -
               border-bottom: 1px solid #444;

     

       531
       531
       -
             `;

     

       532
       532
       -
             userItem.onmouseover = () => {

     

       533
       533
       -
               userItem.style.backgroundColor = "#3A3F55";

     

       534
       534
       -
             };

     

       535
       535
       -
             userItem.onmouseout = () => {

     

       536
       536
       -
               userItem.style.backgroundColor = "";

     

       537
       537
       -
             };

     

       538
       538
       -
       

     

       539
       539
       -
             // Add profile picture

     

       540
       540
       -
             const avatar = document.createElement("img");

     

       541
       541
       -
             avatar.src = user.avatar || "https://bsky.app/static/default-avatar.png";

     

       542
       542
       -
             avatar.style.cssText = `

     

       543
       543
       -
               width: 32px;

     

       544
       544
       -
               height: 32px;

     

       545
       545
       -
               border-radius: 50%;

     

       546
       546
       -
               margin-right: 10px;

     

       547
       547
       -
               object-fit: cover;

     

       548
       548
       -
             `;

     

       549
       549
       -
       

     

       550
       550
       -
             // Add user info

     

       551
       551
       -
             const userInfo = document.createElement("div");

     

       552
       552
       -
             userInfo.style.cssText = `

     

       553
       553
       -
               display: flex;

     

       554
       554
       -
               flex-direction: column;

     

       555
       555
       -
             `;

     

       556
       556
       -
       

     

       557
       557
       -
             const displayName = document.createElement("div");

     

       558
       558
       -
             displayName.textContent = user.displayName || user.handle;

     

       559
       559
       -
             displayName.style.fontWeight = "bold";

     

       560
       560
       -
       

     

       561
       561
       -
             const handle = document.createElement("div");

     

       562
       562
       -
             handle.textContent = user.handle;

     

       563
       563
       -
             handle.style.fontSize = "0.8em";

     

       564
       564
       -
             handle.style.opacity = "0.8";

     

       565
       565
       -
       

     

       566
       566
       -
             userInfo.appendChild(displayName);

     

       567
       567
       -
             userInfo.appendChild(handle);

     

       568
       568
       -
       

     

       569
       569
       -
             userItem.appendChild(avatar);

     

       570
       570
       -
             userItem.appendChild(userInfo);

     

       571
       571
       -
       

     

       572
       572
       -
             // Handle click on user item

     

       573
       573
       -
             userItem.addEventListener("click", () => {

     

       574
       574
       -
               inputElement.value = user.handle;

     

       575
       575
       -
               dropdown.remove();

     

       576
       576
       -
             });

     

       577
       577
       -
       

     

       578
       578
       -
             dropdown.appendChild(userItem);

     

       579
       579
       -
           }

     

       580
       580
       -
       

     

       581
       581
       -
           document.body.appendChild(dropdown);

     

       582
       582
       -
       

     

       583
       583
       -
           // Close dropdown when clicking outside

     

       584
       584
       -
           document.addEventListener("click", function closeDropdown(e) {

     

       585
       585
       -
             if (e.target !== inputElement && !dropdown.contains(e.target)) {

     

       586
       586
       -
               dropdown.remove();

     

       587
       587
       -
               document.removeEventListener("click", closeDropdown);

     

       588
       588
       -
             }

     

       589
       589
       -
           });

     

       590
       590
       -
         };

     

       591
       591
       -
       

     

       592
       592
       -
         // Function to create the settings modal

     

       593
       593
       -
         const createSettingsModal = () => {

     

       594
       594
       -
           // Create modal container

     

       595
       595
       -
           settingsModal = document.createElement("div");

     

       596
       596
       -
           settingsModal.id = "bsky-trusted-settings-modal";

     

       597
       597
       -
           settingsModal.style.cssText = `

     

       598
       598
       -
             display: none;

     

       599
       599
       -
             position: fixed;

     

       600
       600
       -
             top: 0;

     

       601
       601
       -
             left: 0;

     

       602
       602
       -
             width: 100%;

     

       603
       603
       -
             height: 100%;

     

       604
       604
       -
             background-color: rgba(0, 0, 0, 0.5);

     

       605
       605
       -
             z-index: 10001;

     

       606
       606
       -
             justify-content: center;

     

       607
       607
       -
             align-items: center;

     

       608
       608
       -
           `;

     

       609
       609
       -
       

     

       610
       610
       -
           // Create modal content

     

       611
       611
       -
           const modalContent = document.createElement("div");

     

       612
       612
       -
           modalContent.style.cssText = `

     

       613
       613
       -
             background-color: #24273A;

     

       614
       614
       -
             padding: 20px;

     

       615
       615
       -
             border-radius: 10px;

     

       616
       616
       -
             width: 400px;

     

       617
       617
       -
             max-height: 80vh;

     

       618
       618
       -
             overflow-y: auto;

     

       619
       619
       -
           `;

     

       620
       620
       -
       

     

       621
       621
       -
           // Create modal header

     

       622
       622
       -
           const modalHeader = document.createElement("div");

     

       623
       623
       -
           modalHeader.innerHTML = `<h2 style="margin-top: 0;">Trusted Bluesky Users</h2>`;

     

       624
       624
       -
       

     

       625
       625
       -
           // Create input form

     

       626
       626
       -
           const form = document.createElement("div");

     

       627
       627
       -
           form.innerHTML = `

     

       628
       628
       -
               <p>Add Bluesky handles you trust:</p>

     

       629
       629
       -
               <div style="display: flex; margin-bottom: 15px; position: relative;">

     

       630
       630
       -
                 <input id="trustedUserInput" type="text" placeholder="Search for a user..." style="flex: 1; padding: 8px; margin-right: 10px; border: 1px solid #ccc; border-radius: 4px;">

     

       631
       631
       -
                 <button id="addTrustedUserBtn" style="background-color: #2D578D; color: white; border: none; border-radius: 4px; padding: 8px 15px; cursor: pointer;">Add</button>

     

       632
       632
       -
               </div>

     

       633
       633
       -
             `;

     

       634
       634
       -
       

     

       635
       635
       -
           // Create trusted users list

     

       636
       636
       -
           const trustedUsersList = document.createElement("div");

     

       637
       637
       -
           trustedUsersList.id = "trustedUsersList";

     

       638
       638
       -
           trustedUsersList.style.cssText = `

     

       639
       639
       -
             margin-top: 15px;

     

       640
       640
       -
             border-top: 1px solid #eee;

     

       641
       641
       -
             padding-top: 15px;

     

       642
       642
       -
           `;

     

       643
       643
       -
       

     

       644
       644
       -
           // Create cache control buttons

     

       645
       645
       -
           const cacheControls = document.createElement("div");

     

       646
       646
       -
           cacheControls.style.cssText = `

     

       647
       647
       -
             margin-top: 15px;

     

       648
       648
       -
             padding-top: 15px;

     

       649
       649
       -
             border-top: 1px solid #eee;

     

       650
       650
       -
           `;

     

       651
       651
       -
       

     

       652
       652
       -
           const clearCacheButton = document.createElement("button");

     

       653
       653
       -
           clearCacheButton.textContent = "Clear Verification Cache";

     

       654
       654
       -
           clearCacheButton.style.cssText = `

     

       655
       655
       -
             padding: 8px 15px;

     

       656
       656
       -
             background-color: #735A5A;

     

       657
       657
       -
             color: white;

     

       658
       658
       -
             border: none;

     

       659
       659
       -
             border-radius: 4px;

     

       660
       660
       -
             cursor: pointer;

     

       661
       661
       -
             margin-right: 10px;

     

       662
       662
       -
           `;

     

       663
       663
       -
           clearCacheButton.addEventListener("click", () => {

     

       664
       664
       -
             clearCache();

     

       665
       665
       -
             alert(

     

       666
       666
       -
               "Verification cache cleared. Fresh data will be fetched on next check.",

     

       667
       667
       -
             );

     

       668
       668
       -
           });

     

       669
       669
       -
       

     

       670
       670
       -
           cacheControls.appendChild(clearCacheButton);

     

       671
       671
       -
       

     

       672
       672
       -
           // Create close button

     

       673
       673
       -
           const closeButton = document.createElement("button");

     

       674
       674
       -
           closeButton.textContent = "Close";

     

       675
       675
       -
           closeButton.style.cssText = `

     

       676
       676
       -
             margin-top: 20px;

     

       677
       677
       -
             padding: 8px 15px;

     

       678
       678
       -
             background-color: #473A3A;

     

       679
       679
       -
             border: none;

     

       680
       680
       -
             border-radius: 4px;

     

       681
       681
       -
             cursor: pointer;

     

       682
       682
       -
           `;

     

       683
       683
       -
       

     

       684
       684
       -
           // Assemble modal

     

       685
       685
       -
           modalContent.appendChild(modalHeader);

     

       686
       686
       -
           modalContent.appendChild(form);

     

       687
       687
       -
           modalContent.appendChild(trustedUsersList);

     

       688
       688
       -
           modalContent.appendChild(cacheControls);

     

       689
       689
       -
           modalContent.appendChild(closeButton);

     

       690
       690
       -
           settingsModal.appendChild(modalContent);

     

       691
       691
       -
       

     

       692
       692
       -
           // Add to document

     

       693
       693
       -
           document.body.appendChild(settingsModal);

     

       694
       694
       -
       

     

       695
       695
       -
           const userInput = document.getElementById("trustedUserInput");

     

       696
       696
       -
       

     

       697
       697
       -
           // Add input event for autocomplete

     

       698
       698
       -
           let debounceTimeout;

     

       699
       699
       -
           userInput.addEventListener("input", (e) => {

     

       700
       700
       -
             clearTimeout(debounceTimeout);

     

       701
       701
       -
             debounceTimeout = setTimeout(async () => {

     

       702
       702
       -
               const searchQuery = e.target.value.trim();

     

       703
       703
       -
               if (searchQuery.length >= 2) {

     

       704
       704
       -
                 const results = await searchUsers(searchQuery);

     

       705
       705
       -
                 showAutocompleteResults(results, userInput);

     

       706
       706
       -
               } else {

     

       707
       707
       -
                 const dropdown = document.getElementById("autocomplete-dropdown");

     

       708
       708
       -
                 if (dropdown) dropdown.remove();

     

       709
       709
       -
               }

     

       710
       710
       -
             }, 300); // Debounce for 300ms

     

       711
       711
       -
           });

     

       712
       712
       -
       

     

       713
       713
       -
           // Event listeners

     

       714
       714
       -
           closeButton.addEventListener("click", () => {

     

       715
       715
       -
             settingsModal.style.display = "none";

     

       716
       716
       -
           });

     

       717
       717
       -
       

     

       718
       718
       -
           // Function to add a user from the input field

     

       719
       719
       -
           const addUserFromInput = () => {

     

       720
       720
       -
             const input = document.getElementById("trustedUserInput");

     

       721
       721
       -
             const handle = input.value.trim();

     

       722
       722
       -
             if (handle) {

     

       723
       723
       -
               addTrustedUser(handle);

     

       724
       724
       -
               input.value = "";

     

       725
       725
       -
               updateTrustedUsersList();

     

       726
       726
       -
       

     

       727
       727
       -
               // Remove dropdown if present

     

       728
       728
       -
               const dropdown = document.getElementById("autocomplete-dropdown");

     

       729
       729
       -
               if (dropdown) dropdown.remove();

     

       730
       730
       -
             }

     

       731
       731
       -
           };

     

       732
       732
       -
       

     

       733
       733
       -
           // Add trusted user button event

     

       734
       734
       -
           document

     

       735
       735
       -
             .getElementById("addTrustedUserBtn")

     

       736
       736
       -
             .addEventListener("click", addUserFromInput);

     

       737
       737
       -
       

     

       738
       738
       -
           // Add keydown event to input for Enter key

     

       739
       739
       -
           userInput.addEventListener("keydown", (e) => {

     

       740
       740
       -
             if (e.key === "Enter") {

     

       741
       741
       -
               e.preventDefault();

     

       742
       742
       -
               addUserFromInput();

     

       743
       743
       -
             }

     

       744
       744
       -
           });

     

       745
       745
       -
       

     

       746
       746
       -
           // Close modal when clicking outside

     

       747
       747
       -
           settingsModal.addEventListener("click", (e) => {

     

       748
       748
       -
             if (e.target === settingsModal) {

     

       749
       749
       -
               settingsModal.style.display = "none";

     

       750
       750
       -
             }

     

       751
       751
       -
           });

     

       752
       752
       -
       

     

       753
       753
       -
           // Initialize the list

     

       754
       754
       -
           updateTrustedUsersList();

     

       755
       755
       -
         };

     

       756
       756
       -
       

     

       757
       757
       -
         // Function to create the settings UI if it doesn't exist yet

     

       758
       758
       -
         const createSettingsUI = () => {

     

       759
       759
       -
           // Create pill with buttons

     

       760
       760
       -
           createPillButtons();

     

       761
       761
       -
       

     

       762
       762
       -
           // Create the settings modal if it doesn't exist yet

     

       763
       763
       -
           if (!settingsModal) {

     

       764
       764
       -
             createSettingsModal();

     

       765
       765
       -
           }

     

       766
       766
       -
         };

     

       767
       767
       -
       

     

       768
       768
       -
         // Function to check the current profile

     

       769
       769
       -
         const checkCurrentProfile = () => {

     

       770
       770
       -
           const currentUrl = window.location.href;

     

       771
       771
       -
           // Only trigger on profile pages

     

       772
       772
       -
           if (

     

       773
       773
       -
             currentUrl.match(/bsky\.app\/profile\/[^\/]+$/) ||

     

       774
       774
       -
             currentUrl.match(/bsky\.app\/profile\/[^\/]+\/follows/) ||

     

       775
       775
       -
             currentUrl.match(/bsky\.app\/profile\/[^\/]+\/followers/)

     

       776
       776
       -
           ) {

     

       777
       777
       -
             const handle = currentUrl.split("/profile/")[1].split("/")[0];

     

       778
       778
       -
             console.log("Detected profile page for:", handle);

     

       779
       779
       -
       

     

       780
       780
       -
             // Create and add the settings UI (only once)

     

       781
       781
       -
             createSettingsUI();

     

       782
       782
       -
       

     

       783
       783
       -
             // Fetch user profile data

     

       784
       784
       -
             fetch(

     

       785
       785
       -
               `https://public.api.bsky.app/xrpc/com.atproto.repo.getRecord?repo=${handle}&collection=app.bsky.actor.profile&rkey=self`,

     

       786
       786
       -
             )

     

       787
       787
       -
               .then((response) => response.json())

     

       788
       788
       -
               .then((data) => {

     

       789
       789
       -
                 console.log("User profile data:", data);

     

       790
       790
       -
       

     

       791
       791
       -
                 // Extract the DID from the profile data

     

       792
       792
       -
                 const did = data.uri.split("/")[2];

     

       793
       793
       -
                 console.log("User DID:", did);

     

       794
       794
       -
       

     

       795
       795
       -
                 // Check if any trusted users have verified this profile using the DID

     

       796
       796
       -
                 checkTrustedUserVerifications(did);

     

       797
       797
       -
               })

     

       798
       798
       -
               .catch((error) => {

     

       799
       799
       -
                 console.error("Error checking profile:", error);

     

       800
       800
       -
               });

     

       801
       801
       -
       

     

       802
       802
       -
             console.log("Bluesky profile detected");

     

       803
       803
       -
           } else {

     

       804
       804
       -
             // Not on a profile page, reset state

     

       805
       805
       -
             currentProfileDid = null;

     

       806
       806
       -
             profileVerifiers = [];

     

       807
       807
       -
       

     

       808
       808
       -
             // Remove UI elements if present

     

       809
       809
       -
             const existingBadge = document.getElementById(

     

       810
       810
       -
               "user-trusted-verification-badge",

     

       811
       811
       -
             );

     

       812
       812
       -
             if (existingBadge) {

     

       813
       813
       -
               existingBadge.remove();

     

       814
       814
       -
             }

     

       815
       815
       -
       

     

       816
       816
       -
             const existingPill = document.getElementById(

     

       817
       817
       -
               "trusted-users-pill-container",

     

       818
       818
       -
             );

     

       819
       819
       -
             if (existingPill) {

     

       820
       820
       -
               existingPill.remove();

     

       821
       821
       -
             }

     

       822
       822
       -
           }

     

       823
       823
       -
         };

     

       824
       824
       -
       

     

       825
       825
       -
         // Initial check

     

       826
       826
       -
         checkCurrentProfile();

     

       827
       827
       -
       

     

       828
       828
       -
         // Set up a MutationObserver to watch for URL changes

     

       829
       829
       -
         const observeUrlChanges = () => {

     

       830
       830
       -
           let lastUrl = location.href;

     

       831
       831
       -
       

     

       832
       832
       -
           const observer = new MutationObserver(() => {

     

       833
       833
       -
             if (location.href !== lastUrl) {

     

       834
       834
       -
               const oldUrl = lastUrl;

     

       835
       835
       -
               lastUrl = location.href;

     

       836
       836
       -
               console.log("URL changed from:", oldUrl, "to:", location.href);

     

       837
       837
       -
       

     

       838
       838
       -
               // Reset current profile DID

     

       839
       839
       -
               currentProfileDid = null;

     

       840
       840
       -
               profileVerifiers = [];

     

       841
       841
       -
       

     

       842
       842
       -
               // Clean up UI elements

     

       843
       843
       -
               const existingBadge = document.getElementById(

     

       844
       844
       -
                 "user-trusted-verification-badge",

     

       845
       845
       -
               );

     

       846
       846
       -
               if (existingBadge) {

     

       847
       847
       -
                 existingBadge.remove();

     

       848
       848
       -
               }

     

       849
       849
       -
       

     

       850
       850
       -
               const existingPill = document.getElementById(

     

       851
       851
       -
                 "trusted-users-pill-container",

     

       852
       852
       -
               );

     

       853
       853
       -
               if (existingPill) {

     

       854
       854
       -
                 existingPill.remove();

     

       855
       855
       -
               }

     

       856
       856
       -
       

     

       857
       857
       -
               // Check if we're on a profile page now

     

       858
       858
       -
               setTimeout(checkCurrentProfile, 500); // Small delay to ensure DOM has updated

     

       859
       859
       -
             }

     

       860
       860
       -
           });

     

       861
       861
       -
       

     

       862
       862
       -
           observer.observe(document, { subtree: true, childList: true });

     

       863
       863
       -
         };

     

       864
       864
       -
       

     

       865
       865
       -
         // Start observing for URL changes

     

       866
       866
       -
         observeUrlChanges();

     

       867
       867
       -
       })();

+1369

bluesky-community-verifications.user.js

···

       1
       1
       +
       // ==UserScript==

     

       2
       2
       +
       // @name         Bluesky Community Verifications

     

       3
       3
       +
       // @namespace    https://tangled.sh/@dunkirk.sh/bunplayground

     

       4
       4
       +
       // @version      0.2

     

       5
       5
       +
       // @description  Shows verification badges from trusted community members on Bluesky

     

       6
       6
       +
       // @author       Kieran Klukas

     

       7
       7
       +
       // @match        https://bsky.app/*

     

       8
       8
       +
       // @grant        none

     

       9
       9
       +
       // @run-at       document-end

     

       10
       10
       +
       // ==/UserScript==

     

       11
       11
       +
       

     

       12
       12
       +
       (() => {

     

       13
       13
       +
         // Script has already been initialized check

     

       14
       14
       +
         if (window.bskyTrustedUsersInitialized) {

     

       15
       15
       +
           console.log("Trusted Users script already initialized");

     

       16
       16
       +
           return;

     

       17
       17
       +
         }

     

       18
       18
       +
       

     

       19
       19
       +
         // Mark script as initialized

     

       20
       20
       +
         window.bskyTrustedUsersInitialized = true;

     

       21
       21
       +
       

     

       22
       22
       +
         // Define storage keys

     

       23
       23
       +
         const TRUSTED_USERS_STORAGE_KEY = "bsky_trusted_users";

     

       24
       24
       +
         const VERIFICATION_CACHE_STORAGE_KEY = "bsky_verification_cache";

     

       25
       25
       +
         const CACHE_EXPIRY_TIME = 24 * 60 * 60 * 1000; // 24 hours

     

       26
       26
       +
         const BADGE_TYPE_STORAGE_KEY = "bsky_verification_badge_type";

     

       27
       27
       +
         const BADGE_COLOR_STORAGE_KEY = "bsky_verification_badge_color";

     

       28
       28
       +
       

     

       29
       29
       +
         // Default badge configuration

     

       30
       30
       +
         const DEFAULT_BADGE_TYPE = "checkmark";

     

       31
       31
       +
         const DEFAULT_BADGE_COLOR = "#0070ff";

     

       32
       32
       +
       

     

       33
       33
       +
         // Functions to get/set badge configuration

     

       34
       34
       +
         const getBadgeType = () => {

     

       35
       35
       +
           return localStorage.getItem(BADGE_TYPE_STORAGE_KEY) || DEFAULT_BADGE_TYPE;

     

       36
       36
       +
         };

     

       37
       37
       +
       

     

       38
       38
       +
         const getBadgeColor = () => {

     

       39
       39
       +
           return localStorage.getItem(BADGE_COLOR_STORAGE_KEY) || DEFAULT_BADGE_COLOR;

     

       40
       40
       +
         };

     

       41
       41
       +
       

     

       42
       42
       +
         const saveBadgeType = (type) => {

     

       43
       43
       +
           localStorage.setItem(BADGE_TYPE_STORAGE_KEY, type);

     

       44
       44
       +
         };

     

       45
       45
       +
       

     

       46
       46
       +
         const saveBadgeColor = (color) => {

     

       47
       47
       +
           localStorage.setItem(BADGE_COLOR_STORAGE_KEY, color);

     

       48
       48
       +
         };

     

       49
       49
       +
       

     

       50
       50
       +
         const getBadgeContent = (type) => {

     

       51
       51
       +
           switch (type) {

     

       52
       52
       +
             case "checkmark":

     

       53
       53
       +
               return "✓";

     

       54
       54
       +
             case "star":

     

       55
       55
       +
               return "★";

     

       56
       56
       +
             case "heart":

     

       57
       57
       +
               return "♥";

     

       58
       58
       +
             case "shield":

     

       59
       59
       +
               return "🛡️";

     

       60
       60
       +
             case "lock":

     

       61
       61
       +
               return "🔒";

     

       62
       62
       +
             case "verified":

     

       63
       63
       +
               return `<svg viewBox="0 0 24 24" width="16" height="16">

     

       64
       64
       +
                         <path fill="white" d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path>

     

       65
       65
       +
                       </svg>`;

     

       66
       66
       +
             default:

     

       67
       67
       +
               return "✓";

     

       68
       68
       +
           }

     

       69
       69
       +
         };

     

       70
       70
       +
       

     

       71
       71
       +
         // Function to get trusted users from local storage

     

       72
       72
       +
         const getTrustedUsers = () => {

     

       73
       73
       +
           const storedUsers = localStorage.getItem(TRUSTED_USERS_STORAGE_KEY);

     

       74
       74
       +
           return storedUsers ? JSON.parse(storedUsers) : [];

     

       75
       75
       +
         };

     

       76
       76
       +
       

     

       77
       77
       +
         // Function to save trusted users to local storage

     

       78
       78
       +
         const saveTrustedUsers = (users) => {

     

       79
       79
       +
           localStorage.setItem(TRUSTED_USERS_STORAGE_KEY, JSON.stringify(users));

     

       80
       80
       +
         };

     

       81
       81
       +
       

     

       82
       82
       +
         // Populate default trusted users if not already set

     

       83
       83
       +
         if (!localStorage.getItem(TRUSTED_USERS_STORAGE_KEY)) {

     

       84
       84
       +
           const defaultTrustedUsers = [

     

       85
       85
       +
             "bsky.app",

     

       86
       86
       +
             "nytimes.com",

     

       87
       87
       +
             "wired.com",

     

       88
       88
       +
             "theathletic.bsky.social",

     

       89
       89
       +
           ];

     

       90
       90
       +
           saveTrustedUsers(defaultTrustedUsers);

     

       91
       91
       +
           console.log("Added default trusted users:", defaultTrustedUsers);

     

       92
       92
       +
         }

     

       93
       93
       +
       

     

       94
       94
       +
         // Function to add a trusted user

     

       95
       95
       +
         const addTrustedUser = (handle) => {

     

       96
       96
       +
           const users = getTrustedUsers();

     

       97
       97
       +
           if (!users.includes(handle)) {

     

       98
       98
       +
             users.push(handle);

     

       99
       99
       +
             saveTrustedUsers(users);

     

       100
       100
       +
           }

     

       101
       101
       +
         };

     

       102
       102
       +
       

     

       103
       103
       +
         // Function to remove a trusted user

     

       104
       104
       +
         const removeTrustedUser = (handle) => {

     

       105
       105
       +
           const users = getTrustedUsers();

     

       106
       106
       +
           const updatedUsers = users.filter((user) => user !== handle);

     

       107
       107
       +
           saveTrustedUsers(updatedUsers);

     

       108
       108
       +
         };

     

       109
       109
       +
       

     

       110
       110
       +
         // Cache functions

     

       111
       111
       +
         const getVerificationCache = () => {

     

       112
       112
       +
           const cache = localStorage.getItem(VERIFICATION_CACHE_STORAGE_KEY);

     

       113
       113
       +
           return cache ? JSON.parse(cache) : {};

     

       114
       114
       +
         };

     

       115
       115
       +
       

     

       116
       116
       +
         const saveVerificationCache = (cache) => {

     

       117
       117
       +
           localStorage.setItem(VERIFICATION_CACHE_STORAGE_KEY, JSON.stringify(cache));

     

       118
       118
       +
         };

     

       119
       119
       +
       

     

       120
       120
       +
         const getCachedVerifications = (user) => {

     

       121
       121
       +
           const cache = getVerificationCache();

     

       122
       122
       +
           return cache[user] || null;

     

       123
       123
       +
         };

     

       124
       124
       +
       

     

       125
       125
       +
         const cacheVerifications = (user, records) => {

     

       126
       126
       +
           const cache = getVerificationCache();

     

       127
       127
       +
           cache[user] = {

     

       128
       128
       +
             records,

     

       129
       129
       +
             timestamp: Date.now(),

     

       130
       130
       +
           };

     

       131
       131
       +
           saveVerificationCache(cache);

     

       132
       132
       +
         };

     

       133
       133
       +
       

     

       134
       134
       +
         const isCacheValid = (cacheEntry) => {

     

       135
       135
       +
           return cacheEntry && Date.now() - cacheEntry.timestamp < CACHE_EXPIRY_TIME;

     

       136
       136
       +
         };

     

       137
       137
       +
       

     

       138
       138
       +
         // Function to remove a specific user from the verification cache

     

       139
       139
       +
         const removeUserFromCache = (handle) => {

     

       140
       140
       +
           const cache = getVerificationCache();

     

       141
       141
       +
           if (cache[handle]) {

     

       142
       142
       +
             delete cache[handle];

     

       143
       143
       +
             saveVerificationCache(cache);

     

       144
       144
       +
             console.log(`Removed ${handle} from verification cache`);

     

       145
       145
       +
           }

     

       146
       146
       +
         };

     

       147
       147
       +
       

     

       148
       148
       +
         const clearCache = () => {

     

       149
       149
       +
           localStorage.removeItem(VERIFICATION_CACHE_STORAGE_KEY);

     

       150
       150
       +
           console.log("Verification cache cleared");

     

       151
       151
       +
         };

     

       152
       152
       +
       

     

       153
       153
       +
         // Store all verifiers for a profile

     

       154
       154
       +
         let profileVerifiers = [];

     

       155
       155
       +
       

     

       156
       156
       +
         // Store current profile DID

     

       157
       157
       +
         let currentProfileDid = null;

     

       158
       158
       +
       

     

       159
       159
       +
         // Function to check if a trusted user has verified the current profile

     

       160
       160
       +
         const checkTrustedUserVerifications = async (profileDid) => {

     

       161
       161
       +
           currentProfileDid = profileDid; // Store for recheck functionality

     

       162
       162
       +
           const trustedUsers = getTrustedUsers();

     

       163
       163
       +
           profileVerifiers = []; // Reset the verifiers list

     

       164
       164
       +
       

     

       165
       165
       +
           if (trustedUsers.length === 0) {

     

       166
       166
       +
             console.log("No trusted users to check for verifications");

     

       167
       167
       +
             return false;

     

       168
       168
       +
           }

     

       169
       169
       +
       

     

       170
       170
       +
           console.log(`Checking if any trusted users have verified ${profileDid}`);

     

       171
       171
       +
       

     

       172
       172
       +
           // Use Promise.all to fetch all verification data in parallel

     

       173
       173
       +
           const verificationPromises = trustedUsers.map(async (trustedUser) => {

     

       174
       174
       +
             try {

     

       175
       175
       +
               // Helper function to fetch all verification records with pagination

     

       176
       176
       +
               const fetchAllVerifications = async (user) => {

     

       177
       177
       +
                 // Check cache first

     

       178
       178
       +
                 const cachedData = getCachedVerifications(user);

     

       179
       179
       +
                 if (cachedData && isCacheValid(cachedData)) {

     

       180
       180
       +
                   console.log(`Using cached verification data for ${user}`);

     

       181
       181
       +
                   return cachedData.records;

     

       182
       182
       +
                 }

     

       183
       183
       +
       

     

       184
       184
       +
                 console.log(`Fetching fresh verification data for ${user}`);

     

       185
       185
       +
                 let allRecords = [];

     

       186
       186
       +
                 let cursor = null;

     

       187
       187
       +
                 let hasMore = true;

     

       188
       188
       +
       

     

       189
       189
       +
                 while (hasMore) {

     

       190
       190
       +
                   const url = cursor

     

       191
       191
       +
                     ? `https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=${user}&collection=app.bsky.graph.verification&cursor=${cursor}`

     

       192
       192
       +
                     : `https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=${user}&collection=app.bsky.graph.verification`;

     

       193
       193
       +
       

     

       194
       194
       +
                   const response = await fetch(url);

     

       195
       195
       +
                   const data = await response.json();

     

       196
       196
       +
       

     

       197
       197
       +
                   if (data.records && data.records.length > 0) {

     

       198
       198
       +
                     allRecords = [...allRecords, ...data.records];

     

       199
       199
       +
                   }

     

       200
       200
       +
       

     

       201
       201
       +
                   if (data.cursor) {

     

       202
       202
       +
                     cursor = data.cursor;

     

       203
       203
       +
                   } else {

     

       204
       204
       +
                     hasMore = false;

     

       205
       205
       +
                   }

     

       206
       206
       +
                 }

     

       207
       207
       +
       

     

       208
       208
       +
                 // Save to cache

     

       209
       209
       +
                 cacheVerifications(user, allRecords);

     

       210
       210
       +
                 return allRecords;

     

       211
       211
       +
               };

     

       212
       212
       +
       

     

       213
       213
       +
               // Fetch all verification records for this trusted user

     

       214
       214
       +
               const records = await fetchAllVerifications(trustedUser);

     

       215
       215
       +
       

     

       216
       216
       +
               console.log(`Received verification data from ${trustedUser}`, {

     

       217
       217
       +
                 records,

     

       218
       218
       +
               });

     

       219
       219
       +
       

     

       220
       220
       +
               // Check if this trusted user has verified the current profile

     

       221
       221
       +
               if (records.length > 0) {

     

       222
       222
       +
                 for (const record of records) {

     

       223
       223
       +
                   if (record.value && record.value.subject === profileDid) {

     

       224
       224
       +
                     console.log(

     

       225
       225
       +
                       `${profileDid} is verified by trusted user ${trustedUser}`,

     

       226
       226
       +
                     );

     

       227
       227
       +
       

     

       228
       228
       +
                     // Add to verifiers list

     

       229
       229
       +
                     profileVerifiers.push(trustedUser);

     

       230
       230
       +
                     break; // Once we find a verification, we can stop checking

     

       231
       231
       +
                   }

     

       232
       232
       +
                 }

     

       233
       233
       +
               }

     

       234
       234
       +
               return { trustedUser, success: true };

     

       235
       235
       +
             } catch (error) {

     

       236
       236
       +
               console.error(

     

       237
       237
       +
                 `Error checking verifications from ${trustedUser}:`,

     

       238
       238
       +
                 error,

     

       239
       239
       +
               );

     

       240
       240
       +
               return { trustedUser, success: false, error };

     

       241
       241
       +
             }

     

       242
       242
       +
           });

     

       243
       243
       +
       

     

       244
       244
       +
           // Wait for all verification checks to complete

     

       245
       245
       +
           const results = await Promise.all(verificationPromises);

     

       246
       246
       +
       

     

       247
       247
       +
           // Log summary of API calls

     

       248
       248
       +
           console.log(`API calls completed: ${results.length}`);

     

       249
       249
       +
           console.log(`Successful calls: ${results.filter((r) => r.success).length}`);

     

       250
       250
       +
           console.log(`Failed calls: ${results.filter((r) => !r.success).length}`);

     

       251
       251
       +
       

     

       252
       252
       +
           // If we have verifiers, display the badge

     

       253
       253
       +
           if (profileVerifiers.length > 0) {

     

       254
       254
       +
             displayVerificationBadge(profileVerifiers);

     

       255
       255
       +
             return true;

     

       256
       256
       +
           }

     

       257
       257
       +
       

     

       258
       258
       +
           console.log(`${profileDid} is not verified by any trusted users`);

     

       259
       259
       +
       

     

       260
       260
       +
           return false;

     

       261
       261
       +
         };

     

       262
       262
       +
       

     

       263
       263
       +
         // Function to display verification badge on the profile

     

       264
       264
       +
         const displayVerificationBadge = (verifierHandles) => {

     

       265
       265
       +
           // Find the profile header or name element to add the badge to

     

       266
       266
       +
           const nameElements = document.querySelectorAll(

     

       267
       267
       +
             '[data-testid="profileHeaderDisplayName"]',

     

       268
       268
       +
           );

     

       269
       269
       +
           const nameElement = nameElements[nameElements.length - 1];

     

       270
       270
       +
       

     

       271
       271
       +
           console.log("nameElement", nameElement);

     

       272
       272
       +
       

     

       273
       273
       +
           if (nameElement) {

     

       274
       274
       +
             // Remove existing badge if present

     

       275
       275
       +
             const existingBadge = document.getElementById(

     

       276
       276
       +
               "user-trusted-verification-badge",

     

       277
       277
       +
             );

     

       278
       278
       +
             if (existingBadge) {

     

       279
       279
       +
               existingBadge.remove();

     

       280
       280
       +
             }

     

       281
       281
       +
       

     

       282
       282
       +
             const badge = document.createElement("span");

     

       283
       283
       +
             badge.id = "user-trusted-verification-badge";

     

       284
       284
       +
       

     

       285
       285
       +
             // Get user badge preferences

     

       286
       286
       +
             const badgeType = getBadgeType();

     

       287
       287
       +
             const badgeColor = getBadgeColor();

     

       288
       288
       +
       

     

       289
       289
       +
             // Set badge content based on type

     

       290
       290
       +
             badge.innerHTML = getBadgeContent(badgeType);

     

       291
       291
       +
       

     

       292
       292
       +
             // check if there is a div with button underneath

     

       293
       293
       +
             // Check if this user is verified by Bluesky

     

       294
       294
       +
             const isBlueskyVerified = nameElement.querySelector("div button");

     

       295
       295
       +
             if (isBlueskyVerified) isBlueskyVerified.remove();

     

       296
       296
       +
       

     

       297
       297
       +
             // Create tooltip text with all verifiers

     

       298
       298
       +
             const verifiersText =

     

       299
       299
       +
               verifierHandles.length > 1

     

       300
       300
       +
                 ? `Verified by: ${verifierHandles.join(", ")}`

     

       301
       301
       +
                 : `Verified by ${verifierHandles[0]}`;

     

       302
       302
       +
       

     

       303
       303
       +
             badge.title = verifiersText;

     

       304
       304
       +
             badge.style.cssText = `

     

       305
       305
       +
               background-color: ${badgeColor};

     

       306
       306
       +
               color: white;

     

       307
       307
       +
               border-radius: 50%;

     

       308
       308
       +
               width: 22px;

     

       309
       309
       +
               height: 22px;

     

       310
       310
       +
               margin-left: 8px;

     

       311
       311
       +
               font-size: 14px;

     

       312
       312
       +
               font-weight: bold;

     

       313
       313
       +
               cursor: help;

     

       314
       314
       +
               display: inline-flex;

     

       315
       315
       +
               align-items: center;

     

       316
       316
       +
               justify-content: center;

     

       317
       317
       +
             `;

     

       318
       318
       +
       

     

       319
       319
       +
             // Add a click event to show all verifiers

     

       320
       320
       +
             badge.addEventListener("click", (e) => {

     

       321
       321
       +
               e.stopPropagation();

     

       322
       322
       +
               showVerifiersPopup(verifierHandles);

     

       323
       323
       +
             });

     

       324
       324
       +
       

     

       325
       325
       +
             nameElement.appendChild(badge);

     

       326
       326
       +
           }

     

       327
       327
       +
         };

     

       328
       328
       +
       

     

       329
       329
       +
         // Function to show a popup with all verifiers

     

       330
       330
       +
         const showVerifiersPopup = (verifierHandles) => {

     

       331
       331
       +
           // Remove existing popup if any

     

       332
       332
       +
           const existingPopup = document.getElementById("verifiers-popup");

     

       333
       333
       +
           if (existingPopup) {

     

       334
       334
       +
             existingPopup.remove();

     

       335
       335
       +
           }

     

       336
       336
       +
       

     

       337
       337
       +
           // Create popup

     

       338
       338
       +
           const popup = document.createElement("div");

     

       339
       339
       +
           popup.id = "verifiers-popup";

     

       340
       340
       +
           popup.style.cssText = `

     

       341
       341
       +
             position: fixed;

     

       342
       342
       +
             top: 50%;

     

       343
       343
       +
             left: 50%;

     

       344
       344
       +
             transform: translate(-50%, -50%);

     

       345
       345
       +
             background-color: #24273A;

     

       346
       346
       +
             padding: 20px;

     

       347
       347
       +
             border-radius: 10px;

     

       348
       348
       +
             z-index: 10002;

     

       349
       349
       +
             box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);

     

       350
       350
       +
             max-width: 400px;

     

       351
       351
       +
             width: 90%;

     

       352
       352
       +
           `;

     

       353
       353
       +
       

     

       354
       354
       +
           // Create popup content

     

       355
       355
       +
           popup.innerHTML = `

     

       356
       356
       +
             <h3 style="margin-top: 0; color: white;">Profile Verifiers</h3>

     

       357
       357
       +
             <div style="max-height: 300px; overflow-y: auto;">

     

       358
       358
       +
               ${verifierHandles

     

       359
       359
       +
                 .map(

     

       360
       360
       +
                   (handle) => `

     

       361
       361
       +
                 <div style="padding: 8px 0; border-bottom: 1px solid #444; color: white;">

     

       362
       362
       +
                   ${handle}

     

       363
       363
       +
                 </div>

     

       364
       364
       +
               `,

     

       365
       365
       +
                 )

     

       366
       366
       +
                 .join("")}

     

       367
       367
       +
             </div>

     

       368
       368
       +
             <button id="close-verifiers-popup" style="

     

       369
       369
       +
               margin-top: 15px;

     

       370
       370
       +
               padding: 8px 15px;

     

       371
       371
       +
               background-color: #473A3A;

     

       372
       372
       +
               color: white;

     

       373
       373
       +
               border: none;

     

       374
       374
       +
               border-radius: 4px;

     

       375
       375
       +
               cursor: pointer;

     

       376
       376
       +
             ">Close</button>

     

       377
       377
       +
           `;

     

       378
       378
       +
       

     

       379
       379
       +
           // Add to body

     

       380
       380
       +
           document.body.appendChild(popup);

     

       381
       381
       +
       

     

       382
       382
       +
           // Add close handler

     

       383
       383
       +
           document

     

       384
       384
       +
             .getElementById("close-verifiers-popup")

     

       385
       385
       +
             .addEventListener("click", () => {

     

       386
       386
       +
               popup.remove();

     

       387
       387
       +
             });

     

       388
       388
       +
       

     

       389
       389
       +
           // Close when clicking outside

     

       390
       390
       +
           document.addEventListener("click", function closePopup(e) {

     

       391
       391
       +
             if (!popup.contains(e.target)) {

     

       392
       392
       +
               popup.remove();

     

       393
       393
       +
               document.removeEventListener("click", closePopup);

     

       394
       394
       +
             }

     

       395
       395
       +
           });

     

       396
       396
       +
         };

     

       397
       397
       +
       

     

       398
       398
       +
         // Create settings modal

     

       399
       399
       +
         let settingsModal = null;

     

       400
       400
       +
       

     

       401
       401
       +
         // Function to update the list of trusted users in the UI

     

       402
       402
       +
         const updateTrustedUsersList = () => {

     

       403
       403
       +
           const trustedUsersList = document.getElementById("trustedUsersList");

     

       404
       404
       +
           if (!trustedUsersList) return;

     

       405
       405
       +
       

     

       406
       406
       +
           const users = getTrustedUsers();

     

       407
       407
       +
           trustedUsersList.innerHTML = "";

     

       408
       408
       +
       

     

       409
       409
       +
           if (users.length === 0) {

     

       410
       410
       +
             trustedUsersList.innerHTML = "<p>No trusted users added yet.</p>";

     

       411
       411
       +
             return;

     

       412
       412
       +
           }

     

       413
       413
       +
       

     

       414
       414
       +
           for (const user of users) {

     

       415
       415
       +
             const userItem = document.createElement("div");

     

       416
       416
       +
             userItem.style.cssText = `

     

       417
       417
       +
               display: flex;

     

       418
       418
       +
               justify-content: space-between;

     

       419
       419
       +
               align-items: center;

     

       420
       420
       +
               padding: 8px 0;

     

       421
       421
       +
               border-bottom: 1px solid #eee;

     

       422
       422
       +
             `;

     

       423
       423
       +
       

     

       424
       424
       +
             userItem.innerHTML = `

     

       425
       425
       +
               <span>${user}</span>

     

       426
       426
       +
               <button class="remove-user" data-handle="${user}" style="background-color: #CE3838; color: white; border: none; border-radius: 4px; padding: 5px 10px; cursor: pointer;">Remove</button>

     

       427
       427
       +
             `;

     

       428
       428
       +
       

     

       429
       429
       +
             trustedUsersList.appendChild(userItem);

     

       430
       430
       +
           }

     

       431
       431
       +
       

     

       432
       432
       +
           // Add event listeners to remove buttons

     

       433
       433
       +
           const removeButtons = document.querySelectorAll(".remove-user");

     

       434
       434
       +
           for (const btn of removeButtons) {

     

       435
       435
       +
             btn.addEventListener("click", (e) => {

     

       436
       436
       +
               const handle = e.target.getAttribute("data-handle");

     

       437
       437
       +
               removeTrustedUser(handle);

     

       438
       438
       +
               removeUserFromCache(handle);

     

       439
       439
       +
               updateTrustedUsersList();

     

       440
       440
       +
             });

     

       441
       441
       +
           }

     

       442
       442
       +
         };

     

       443
       443
       +
       

     

       444
       444
       +
         const searchUsers = async (searchQuery) => {

     

       445
       445
       +
           if (!searchQuery || searchQuery.length < 2) return [];

     

       446
       446
       +
       

     

       447
       447
       +
           try {

     

       448
       448
       +
             const response = await fetch(

     

       449
       449
       +
               `https://public.api.bsky.app/xrpc/app.bsky.actor.searchActors?term=${encodeURIComponent(searchQuery)}&limit=5`,

     

       450
       450
       +
             );

     

       451
       451
       +
             const data = await response.json();

     

       452
       452
       +
             return data.actors || [];

     

       453
       453
       +
           } catch (error) {

     

       454
       454
       +
             console.error("Error searching for users:", error);

     

       455
       455
       +
             return [];

     

       456
       456
       +
           }

     

       457
       457
       +
         };

     

       458
       458
       +
       

     

       459
       459
       +
         // Function to create and show the autocomplete dropdown

     

       460
       460
       +
         const showAutocompleteResults = (results, inputElement) => {

     

       461
       461
       +
           // Remove existing dropdown if any

     

       462
       462
       +
           const existingDropdown = document.getElementById("autocomplete-dropdown");

     

       463
       463
       +
           if (existingDropdown) existingDropdown.remove();

     

       464
       464
       +
       

     

       465
       465
       +
           if (results.length === 0) return;

     

       466
       466
       +
       

     

       467
       467
       +
           // Create dropdown

     

       468
       468
       +
           const dropdown = document.createElement("div");

     

       469
       469
       +
           dropdown.id = "autocomplete-dropdown";

     

       470
       470
       +
           dropdown.style.cssText = `

     

       471
       471
       +
             position: absolute;

     

       472
       472
       +
             background-color: #2A2E3D;

     

       473
       473
       +
             border: 1px solid #444;

     

       474
       474
       +
             border-radius: 4px;

     

       475
       475
       +
             box-shadow: 0 4px 8px rgba(0,0,0,0.2);

     

       476
       476
       +
             max-height: 300px;

     

       477
       477
       +
             overflow-y: auto;

     

       478
       478
       +
             width: ${inputElement.offsetWidth}px;

     

       479
       479
       +
             z-index: 10002;

     

       480
       480
       +
             margin-top: 2px;

     

       481
       481
       +
           `;

     

       482
       482
       +
       

     

       483
       483
       +
           // Position dropdown below input

     

       484
       484
       +
           const inputRect = inputElement.getBoundingClientRect();

     

       485
       485
       +
           dropdown.style.left = `${inputRect.left}px`;

     

       486
       486
       +
           dropdown.style.top = `${inputRect.bottom}px`;

     

       487
       487
       +
       

     

       488
       488
       +
           // Add results to dropdown

     

       489
       489
       +
           for (const user of results) {

     

       490
       490
       +
             const userItem = document.createElement("div");

     

       491
       491
       +
             userItem.className = "autocomplete-item";

     

       492
       492
       +
             userItem.style.cssText = `

     

       493
       493
       +
               display: flex;

     

       494
       494
       +
               align-items: center;

     

       495
       495
       +
               padding: 8px 12px;

     

       496
       496
       +
               cursor: pointer;

     

       497
       497
       +
               color: white;

     

       498
       498
       +
               border-bottom: 1px solid #444;

     

       499
       499
       +
             `;

     

       500
       500
       +
             userItem.onmouseover = () => {

     

       501
       501
       +
               userItem.style.backgroundColor = "#3A3F55";

     

       502
       502
       +
             };

     

       503
       503
       +
             userItem.onmouseout = () => {

     

       504
       504
       +
               userItem.style.backgroundColor = "";

     

       505
       505
       +
             };

     

       506
       506
       +
       

     

       507
       507
       +
             // Add profile picture

     

       508
       508
       +
             const avatar = document.createElement("img");

     

       509
       509
       +
             avatar.src = user.avatar || "https://bsky.app/static/default-avatar.png";

     

       510
       510
       +
             avatar.style.cssText = `

     

       511
       511
       +
               width: 32px;

     

       512
       512
       +
               height: 32px;

     

       513
       513
       +
               border-radius: 50%;

     

       514
       514
       +
               margin-right: 10px;

     

       515
       515
       +
               object-fit: cover;

     

       516
       516
       +
             `;

     

       517
       517
       +
       

     

       518
       518
       +
             // Add user info

     

       519
       519
       +
             const userInfo = document.createElement("div");

     

       520
       520
       +
             userInfo.style.cssText = `

     

       521
       521
       +
               display: flex;

     

       522
       522
       +
               flex-direction: column;

     

       523
       523
       +
             `;

     

       524
       524
       +
       

     

       525
       525
       +
             const displayName = document.createElement("div");

     

       526
       526
       +
             displayName.textContent = user.displayName || user.handle;

     

       527
       527
       +
             displayName.style.fontWeight = "bold";

     

       528
       528
       +
       

     

       529
       529
       +
             const handle = document.createElement("div");

     

       530
       530
       +
             handle.textContent = user.handle;

     

       531
       531
       +
             handle.style.fontSize = "0.8em";

     

       532
       532
       +
             handle.style.opacity = "0.8";

     

       533
       533
       +
       

     

       534
       534
       +
             userInfo.appendChild(displayName);

     

       535
       535
       +
             userInfo.appendChild(handle);

     

       536
       536
       +
       

     

       537
       537
       +
             userItem.appendChild(avatar);

     

       538
       538
       +
             userItem.appendChild(userInfo);

     

       539
       539
       +
       

     

       540
       540
       +
             // Handle click on user item

     

       541
       541
       +
             userItem.addEventListener("click", () => {

     

       542
       542
       +
               inputElement.value = user.handle;

     

       543
       543
       +
               dropdown.remove();

     

       544
       544
       +
             });

     

       545
       545
       +
       

     

       546
       546
       +
             dropdown.appendChild(userItem);

     

       547
       547
       +
           }

     

       548
       548
       +
       

     

       549
       549
       +
           document.body.appendChild(dropdown);

     

       550
       550
       +
       

     

       551
       551
       +
           // Close dropdown when clicking outside

     

       552
       552
       +
           document.addEventListener("click", function closeDropdown(e) {

     

       553
       553
       +
             if (e.target !== inputElement && !dropdown.contains(e.target)) {

     

       554
       554
       +
               dropdown.remove();

     

       555
       555
       +
               document.removeEventListener("click", closeDropdown);

     

       556
       556
       +
             }

     

       557
       557
       +
           });

     

       558
       558
       +
         };

     

       559
       559
       +
       

     

       560
       560
       +
         // Function to import verifications from the current user

     

       561
       561
       +
         const importVerificationsFromSelf = async () => {

     

       562
       562
       +
           try {

     

       563
       563
       +
             // Check if we can determine the current user

     

       564
       564
       +
             const bskyStorageData = localStorage.getItem("BSKY_STORAGE");

     

       565
       565
       +
             let userData = null;

     

       566
       566
       +
       

     

       567
       567
       +
             if (bskyStorageData) {

     

       568
       568
       +
               try {

     

       569
       569
       +
                 const bskyStorage = JSON.parse(bskyStorageData);

     

       570
       570
       +
                 if (bskyStorage.session.currentAccount) {

     

       571
       571
       +
                   userData = bskyStorage.session.currentAccount;

     

       572
       572
       +
                 }

     

       573
       573
       +
               } catch (error) {

     

       574
       574
       +
                 console.error("Error parsing BSKY_STORAGE data:", error);

     

       575
       575
       +
               }

     

       576
       576
       +
             }

     

       577
       577
       +
       

     

       578
       578
       +
             if (!userData || !userData.handle) {

     

       579
       579
       +
               alert(

     

       580
       580
       +
                 "Could not determine your Bluesky handle. Please ensure you're logged in.",

     

       581
       581
       +
               );

     

       582
       582
       +
               return;

     

       583
       583
       +
             }

     

       584
       584
       +
       

     

       585
       585
       +
             if (!userData || !userData.handle) {

     

       586
       586
       +
               alert(

     

       587
       587
       +
                 "Unable to determine your Bluesky handle. Make sure you're logged in.",

     

       588
       588
       +
               );

     

       589
       589
       +
               return;

     

       590
       590
       +
             }

     

       591
       591
       +
       

     

       592
       592
       +
             const userHandle = userData.handle;

     

       593
       593
       +
       

     

       594
       594
       +
             // Show loading state

     

       595
       595
       +
             const importButton = document.getElementById("importVerificationsBtn");

     

       596
       596
       +
             const originalText = importButton.textContent;

     

       597
       597
       +
             importButton.textContent = "Importing...";

     

       598
       598
       +
             importButton.disabled = true;

     

       599
       599
       +
       

     

       600
       600
       +
             // Fetch verification records from the user's account with pagination

     

       601
       601
       +
             let allRecords = [];

     

       602
       602
       +
             let cursor = null;

     

       603
       603
       +
             let hasMore = true;

     

       604
       604
       +
       

     

       605
       605
       +
             while (hasMore) {

     

       606
       606
       +
               const url = cursor

     

       607
       607
       +
                 ? `https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=${userHandle}&collection=app.bsky.graph.verification&cursor=${cursor}`

     

       608
       608
       +
                 : `https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=${userHandle}&collection=app.bsky.graph.verification`;

     

       609
       609
       +
       

     

       610
       610
       +
               const verificationResponse = await fetch(url);

     

       611
       611
       +
               const data = await verificationResponse.json();

     

       612
       612
       +
       

     

       613
       613
       +
               if (data.records && data.records.length > 0) {

     

       614
       614
       +
                 allRecords = [...allRecords, ...data.records];

     

       615
       615
       +
               }

     

       616
       616
       +
       

     

       617
       617
       +
               if (data.cursor) {

     

       618
       618
       +
                 cursor = data.cursor;

     

       619
       619
       +
               } else {

     

       620
       620
       +
                 hasMore = false;

     

       621
       621
       +
               }

     

       622
       622
       +
             }

     

       623
       623
       +
       

     

       624
       624
       +
             const verificationData = { records: allRecords };

     

       625
       625
       +
       

     

       626
       626
       +
             if (!verificationData.records || verificationData.records.length === 0) {

     

       627
       627
       +
               alert("No verification records found in your account.");

     

       628
       628
       +
               importButton.textContent = originalText;

     

       629
       629
       +
               importButton.disabled = false;

     

       630
       630
       +
               return;

     

       631
       631
       +
             }

     

       632
       632
       +
       

     

       633
       633
       +
             // Extract the handles of verified users

     

       634
       634
       +
             const verifiedUsers = [];

     

       635
       635
       +
             for (const record of verificationData.records) {

     

       636
       636
       +
               console.log(record.value.handle);

     

       637
       637
       +
               verifiedUsers.push(record.value.handle);

     

       638
       638
       +
             }

     

       639
       639
       +
       

     

       640
       640
       +
             // Add all found users to trusted users

     

       641
       641
       +
             let addedCount = 0;

     

       642
       642
       +
             for (const handle of verifiedUsers) {

     

       643
       643
       +
               const existingUsers = getTrustedUsers();

     

       644
       644
       +
               if (!existingUsers.includes(handle)) {

     

       645
       645
       +
                 addTrustedUser(handle);

     

       646
       646
       +
                 addedCount++;

     

       647
       647
       +
               }

     

       648
       648
       +
             }

     

       649
       649
       +
       

     

       650
       650
       +
             // Update the UI

     

       651
       651
       +
             updateTrustedUsersList();

     

       652
       652
       +
       

     

       653
       653
       +
             // Reset button state

     

       654
       654
       +
             importButton.textContent = originalText;

     

       655
       655
       +
             importButton.disabled = false;

     

       656
       656
       +
       

     

       657
       657
       +
             // Show result

     

       658
       658
       +
             alert(

     

       659
       659
       +
               `Successfully imported ${addedCount} verified users from your account.`,

     

       660
       660
       +
             );

     

       661
       661
       +
           } catch (error) {

     

       662
       662
       +
             console.error("Error importing verifications:", error);

     

       663
       663
       +
             alert("Error importing verifications. Check console for details.");

     

       664
       664
       +
             const importButton = document.getElementById("importVerificationsBtn");

     

       665
       665
       +
             if (importButton) {

     

       666
       666
       +
               importButton.textContent = "Import Verifications";

     

       667
       667
       +
               importButton.disabled = false;

     

       668
       668
       +
             }

     

       669
       669
       +
           }

     

       670
       670
       +
         };

     

       671
       671
       +
       

     

       672
       672
       +
         const addSettingsButton = () => {

     

       673
       673
       +
           // Check if we're on the settings page

     

       674
       674
       +
           if (!window.location.href.includes("bsky.app/settings")) {

     

       675
       675
       +
             return;

     

       676
       676
       +
           }

     

       677
       677
       +
       

     

       678
       678
       +
           // Check if our button already exists to avoid duplicates

     

       679
       679
       +
           if (document.getElementById("community-verifications-settings-button")) {

     

       680
       680
       +
             return;

     

       681
       681
       +
           }

     

       682
       682
       +
       

     

       683
       683
       +
           // Find the right place to insert our button (after content-and-media link)

     

       684
       684
       +
           const contentMediaLink = document.querySelector(

     

       685
       685
       +
             'a[href="/settings/content-and-media"]',

     

       686
       686
       +
           );

     

       687
       687
       +
           if (!contentMediaLink) {

     

       688
       688
       +
             console.log("Could not find content-and-media link to insert after");

     

       689
       689
       +
             return;

     

       690
       690
       +
           }

     

       691
       691
       +
       

     

       692
       692
       +
           // Clone the existing link and modify it

     

       693
       693
       +
           const verificationButton = contentMediaLink.cloneNode(true);

     

       694
       694
       +
           verificationButton.id = "community-verifications-settings-button";

     

       695
       695
       +
           verificationButton.href = "#"; // No actual link, we'll handle click with JS

     

       696
       696
       +
           verificationButton.setAttribute("aria-label", "Community Verifications");

     

       697
       697
       +
       

     

       698
       698
       +
           const highlightColor =

     

       699
       699
       +
             verificationButton.firstChild.style.backgroundColor || "rgb(30,41,54)";

     

       700
       700
       +
       

     

       701
       701
       +
           // Add hover effect to highlight the button

     

       702
       702
       +
           verificationButton.addEventListener("mouseover", () => {

     

       703
       703
       +
             verificationButton.firstChild.style.backgroundColor = highlightColor;

     

       704
       704
       +
           });

     

       705
       705
       +
       

     

       706
       706
       +
           verificationButton.addEventListener("mouseout", () => {

     

       707
       707
       +
             verificationButton.firstChild.style.backgroundColor = null;

     

       708
       708
       +
           });

     

       709
       709
       +
       

     

       710
       710
       +
           // Update the text content

     

       711
       711
       +
           const textDiv = verificationButton.querySelector(".css-146c3p1");

     

       712
       712
       +
           if (textDiv) {

     

       713
       713
       +
             textDiv.textContent = "Community Verifications";

     

       714
       714
       +
           }

     

       715
       715
       +
       

     

       716
       716
       +
           // Update the icon

     

       717
       717
       +
           const iconDiv = verificationButton.querySelector(

     

       718
       718
       +
             ".css-175oi2r[style*='width: 28px']",

     

       719
       719
       +
           );

     

       720
       720
       +
           if (iconDiv) {

     

       721
       721
       +
             iconDiv.innerHTML = `

     

       722
       722
       +
               <svg fill="none" width="28" viewBox="0 0 24 24" height="28" style="color: rgb(241, 243, 245);">

     

       723
       723
       +
                 <path fill="hsl(211, 20%, 95.3%)" d="M21.2,9.3c-0.5-0.5-1.1-0.7-1.8-0.7h-2.3V6.3c0-2.1-1.7-3.7-3.7-3.7h-3c-2.1,0-3.7,1.7-3.7,3.7v2.3H4.6

     

       724
       724
       +
                 c-0.7,0-1.3,0.3-1.8,0.7c-0.5,0.5-0.7,1.1-0.7,1.8v9.3c0,0.7,0.3,1.3,0.7,1.8c0.5,0.5,1.1,0.7,1.8,0.7h14.9c0.7,0,1.3-0.3,1.8-0.7

     

       725
       725
       +
                 c0.5-0.5,0.7-1.1,0.7-1.8v-9.3C22,10.4,21.7,9.8,21.2,9.3z M14.1,15.6l-1.3,1.3c-0.1,0.1-0.3,0.2-0.5,0.2c-0.2,0-0.3-0.1-0.5-0.2l-3.3-3.3

     

       726
       726
       +
                 c-0.1-0.1-0.2-0.3-0.2-0.5c0-0.2,0.1-0.3,0.2-0.5l1.3-1.3c0.1-0.1,0.3-0.2,0.5-0.2c0.2,0,0.3,0.1,0.5,0.2l1.5,1.5l4.2-4.2

     

       727
       727
       +
                 c0.1-0.1,0.3-0.2,0.5-0.2c0.2,0,0.3,0.1,0.5,0.2l1.3,1.3c0.1,0.1,0.2,0.3,0.2,0.5c0,0.2-0.1,0.3-0.2,0.5L14.1,15.6z M9.7,6.3

     

       728
       728
       +
                 c0-0.9,0.7-1.7,1.7-1.7h3c0.9,0,1.7,0.7,1.7,1.7v2.3H9.7V6.3z"/>

     

       729
       729
       +
               </svg>

     

       730
       730
       +
             `;

     

       731
       731
       +
           }

     

       732
       732
       +
       

     

       733
       733
       +
           // Insert our button after the content-and-media link

     

       734
       734
       +
           const parentElement = contentMediaLink.parentElement;

     

       735
       735
       +
           parentElement.insertBefore(

     

       736
       736
       +
             verificationButton,

     

       737
       737
       +
             contentMediaLink.nextSibling,

     

       738
       738
       +
           );

     

       739
       739
       +
       

     

       740
       740
       +
           // Add click event to open our settings modal

     

       741
       741
       +
           verificationButton.addEventListener("click", (e) => {

     

       742
       742
       +
             e.preventDefault();

     

       743
       743
       +
             if (settingsModal) {

     

       744
       744
       +
               settingsModal.style.display = "flex";

     

       745
       745
       +
               updateTrustedUsersList();

     

       746
       746
       +
             } else {

     

       747
       747
       +
               createSettingsModal();

     

       748
       748
       +
             }

     

       749
       749
       +
           });

     

       750
       750
       +
       

     

       751
       751
       +
           console.log("Added Community Verifications button to settings page");

     

       752
       752
       +
         };

     

       753
       753
       +
       

     

       754
       754
       +
         // Function to create the settings modal

     

       755
       755
       +
         const createSettingsModal = () => {

     

       756
       756
       +
           // Create modal container

     

       757
       757
       +
           settingsModal = document.createElement("div");

     

       758
       758
       +
           settingsModal.id = "bsky-trusted-settings-modal";

     

       759
       759
       +
           settingsModal.style.cssText = `

     

       760
       760
       +
             display: flex;

     

       761
       761
       +
             position: fixed;

     

       762
       762
       +
             top: 0;

     

       763
       763
       +
             left: 0;

     

       764
       764
       +
             width: 100%;

     

       765
       765
       +
             height: 100%;

     

       766
       766
       +
             background-color: rgba(0, 0, 0, 0.5);

     

       767
       767
       +
             z-index: 10001;

     

       768
       768
       +
             justify-content: center;

     

       769
       769
       +
             align-items: center;

     

       770
       770
       +
           `;

     

       771
       771
       +
       

     

       772
       772
       +
           // Create modal content

     

       773
       773
       +
           const modalContent = document.createElement("div");

     

       774
       774
       +
           modalContent.style.cssText = `

     

       775
       775
       +
             background-color: #24273A;

     

       776
       776
       +
             padding: 20px;

     

       777
       777
       +
             border-radius: 10px;

     

       778
       778
       +
             width: 400px;

     

       779
       779
       +
             max-height: 80vh;

     

       780
       780
       +
             overflow-y: auto;

     

       781
       781
       +
           `;

     

       782
       782
       +
       

     

       783
       783
       +
           // Create modal header

     

       784
       784
       +
           const modalHeader = document.createElement("div");

     

       785
       785
       +
           modalHeader.innerHTML = `<h2 style="margin-top: 0;">Trusted Bluesky Users</h2>`;

     

       786
       786
       +
       

     

       787
       787
       +
           const badgeCustomization = document.createElement("div");

     

       788
       788
       +
           badgeCustomization.style.cssText = `

     

       789
       789
       +
             margin-top: 15px;

     

       790
       790
       +
             padding-top: 15px;

     

       791
       791
       +
             border-top: 1px solid #eee;

     

       792
       792
       +
           `;

     

       793
       793
       +
       

     

       794
       794
       +
           badgeCustomization.innerHTML = `

     

       795
       795
       +
             <h2 style="margin-top: 0; color: white;">Badge Customization</h3>

     

       796
       796
       +
       

     

       797
       797
       +
             <div style="margin-bottom: 1rem;">

     

       798
       798
       +
               <p style="margin-bottom: 8px; color: white;">Badge Type:</p>

     

       799
       799
       +
               <div style="display: flex; flex-wrap: wrap; gap: 10px;">

     

       800
       800
       +
                 <label style="display: flex; align-items: center; cursor: pointer; color: white;">

     

       801
       801
       +
                   <input type="radio" name="badgeType" value="checkmark" ${getBadgeType() === "checkmark" ? "checked" : ""}>

     

       802
       802
       +
                   <span style="margin-left: 5px;">Checkmark (✓)</span>

     

       803
       803
       +
                 </label>

     

       804
       804
       +
                 <label style="display: flex; align-items: center; cursor: pointer; color: white;">

     

       805
       805
       +
                   <input type="radio" name="badgeType" value="star" ${getBadgeType() === "star" ? "checked" : ""}>

     

       806
       806
       +
                   <span style="margin-left: 5px;">Star (★)</span>

     

       807
       807
       +
                 </label>

     

       808
       808
       +
                 <label style="display: flex; align-items: center; cursor: pointer; color: white;">

     

       809
       809
       +
                   <input type="radio" name="badgeType" value="heart" ${getBadgeType() === "heart" ? "checked" : ""}>

     

       810
       810
       +
                   <span style="margin-left: 5px;">Heart (♥)</span>

     

       811
       811
       +
                 </label>

     

       812
       812
       +
                 <label style="display: flex; align-items: center; cursor: pointer; color: white;">

     

       813
       813
       +
                   <input type="radio" name="badgeType" value="shield" ${getBadgeType() === "shield" ? "checked" : ""}>

     

       814
       814
       +
                   <span style="margin-left: 5px;">Shield (🛡️)</span>

     

       815
       815
       +
                 </label>

     

       816
       816
       +
                 <label style="display: flex; align-items: center; cursor: pointer; color: white;">

     

       817
       817
       +
                   <input type="radio" name="badgeType" value="lock" ${getBadgeType() === "lock" ? "checked" : ""}>

     

       818
       818
       +
                   <span style="margin-left: 5px;">Lock (🔒)</span>

     

       819
       819
       +
                 </label>

     

       820
       820
       +
                 <label style="display: flex; align-items: center; cursor: pointer; color: white;">

     

       821
       821
       +
                   <input type="radio" name="badgeType" value="verified" ${getBadgeType() === "verified" ? "checked" : ""}>

     

       822
       822
       +
                   <span style="margin-left: 5px;">Verified</span>

     

       823
       823
       +
                 </label>

     

       824
       824
       +
               </div>

     

       825
       825
       +
             </div>

     

       826
       826
       +
       

     

       827
       827
       +
             <div>

     

       828
       828
       +
               <p style="margin-bottom: 8px; color: white;">Badge Color:</p>

     

       829
       829
       +
               <div style="display: flex; align-items: center;">

     

       830
       830
       +
                 <input type="color" id="badgeColorPicker" value="${getBadgeColor()}" style="margin-right: 10px;">

     

       831
       831
       +
                 <span id="badgeColorPreview" style="display: inline-block; width: 24px; height: 24px; background-color: ${getBadgeColor()}; border-radius: 50%; margin-right: 10px;"></span>

     

       832
       832
       +
                 <button id="resetBadgeColor" style="padding: 5px 10px; background: #473A3A; color: white; border: none; border-radius: 4px; cursor: pointer;">Reset to Default</button>

     

       833
       833
       +
               </div>

     

       834
       834
       +
             </div>

     

       835
       835
       +
       

     

       836
       836
       +
             <div style="margin-top: 20px; margin-bottom: 1rem;">

     

       837
       837
       +
               <p style="color: white;">Preview:</p>

     

       838
       838
       +
               <div style="display: flex; align-items: center; margin-top: 8px;">

     

       839
       839
       +
                 <span style="color: white; font-weight: bold;">User Name</span>

     

       840
       840
       +
                 <span id="badgePreview" style="

     

       841
       841
       +
                   background-color: ${getBadgeColor()};

     

       842
       842
       +
                   color: white;

     

       843
       843
       +
                   border-radius: 50%;

     

       844
       844
       +
                   width: 22px;

     

       845
       845
       +
                   height: 22px;

     

       846
       846
       +
                   margin-left: 8px;

     

       847
       847
       +
                   font-size: 14px;

     

       848
       848
       +
                   font-weight: bold;

     

       849
       849
       +
                   display: inline-flex;

     

       850
       850
       +
                   align-items: center;

     

       851
       851
       +
                   justify-content: center;

     

       852
       852
       +
                 ">${getBadgeContent(getBadgeType())}</span>

     

       853
       853
       +
               </div>

     

       854
       854
       +
             </div>

     

       855
       855
       +
           `;

     

       856
       856
       +
       

     

       857
       857
       +
           // Add the badge customization section to the modal content

     

       858
       858
       +
           modalContent.appendChild(badgeCustomization);

     

       859
       859
       +
       

     

       860
       860
       +
           // Add event listeners for the badge customization controls

     

       861
       861
       +
           setTimeout(() => {

     

       862
       862
       +
             // Badge type selection

     

       863
       863
       +
             const badgeTypeRadios = document.querySelectorAll(

     

       864
       864
       +
               'input[name="badgeType"]',

     

       865
       865
       +
             );

     

       866
       866
       +
             for (const radio of badgeTypeRadios) {

     

       867
       867
       +
               radio.addEventListener("change", (e) => {

     

       868
       868
       +
                 const selectedType = e.target.value;

     

       869
       869
       +
                 saveBadgeType(selectedType);

     

       870
       870
       +
                 updateBadgePreview();

     

       871
       871
       +
               });

     

       872
       872
       +
             }

     

       873
       873
       +
       

     

       874
       874
       +
             // Badge color picker

     

       875
       875
       +
             const colorPicker = document.getElementById("badgeColorPicker");

     

       876
       876
       +
             const colorPreview = document.getElementById("badgeColorPreview");

     

       877
       877
       +
       

     

       878
       878
       +
             colorPicker.addEventListener("input", (e) => {

     

       879
       879
       +
               const selectedColor = e.target.value;

     

       880
       880
       +
               colorPreview.style.backgroundColor = selectedColor;

     

       881
       881
       +
               saveBadgeColor(selectedColor);

     

       882
       882
       +
               updateBadgePreview();

     

       883
       883
       +
             });

     

       884
       884
       +
       

     

       885
       885
       +
             // Reset color button

     

       886
       886
       +
             const resetColorBtn = document.getElementById("resetBadgeColor");

     

       887
       887
       +
             resetColorBtn.addEventListener("click", () => {

     

       888
       888
       +
               colorPicker.value = DEFAULT_BADGE_COLOR;

     

       889
       889
       +
               colorPreview.style.backgroundColor = DEFAULT_BADGE_COLOR;

     

       890
       890
       +
               saveBadgeColor(DEFAULT_BADGE_COLOR);

     

       891
       891
       +
               updateBadgePreview();

     

       892
       892
       +
             });

     

       893
       893
       +
       

     

       894
       894
       +
             // Function to update the badge preview

     

       895
       895
       +
             function updateBadgePreview() {

     

       896
       896
       +
               const badgePreview = document.getElementById("badgePreview");

     

       897
       897
       +
               const selectedType = getBadgeType();

     

       898
       898
       +
               const selectedColor = getBadgeColor();

     

       899
       899
       +
       

     

       900
       900
       +
               badgePreview.innerHTML = getBadgeContent(selectedType);

     

       901
       901
       +
               badgePreview.style.backgroundColor = selectedColor;

     

       902
       902
       +
             }

     

       903
       903
       +
       

     

       904
       904
       +
             // Initialize preview

     

       905
       905
       +
             updateBadgePreview();

     

       906
       906
       +
           }, 100);

     

       907
       907
       +
       

     

       908
       908
       +
           // Create input form

     

       909
       909
       +
           const form = document.createElement("div");

     

       910
       910
       +
           form.innerHTML = `

     

       911
       911
       +
               <p>Add Bluesky handles you trust:</p>

     

       912
       912
       +
               <div style="display: flex; margin-bottom: 15px; position: relative;">

     

       913
       913
       +
                 <input id="trustedUserInput" type="text" placeholder="Search for a user..." style="flex: 1; padding: 8px; margin-right: 10px; border: 1px solid #ccc; border-radius: 4px;">

     

       914
       914
       +
                 <button id="addTrustedUserBtn" style="background-color: #2D578D; color: white; border: none; border-radius: 4px; padding: 8px 15px; cursor: pointer;">Add</button>

     

       915
       915
       +
               </div>

     

       916
       916
       +
             `;

     

       917
       917
       +
       

     

       918
       918
       +
           // Create import button

     

       919
       919
       +
           const importContainer = document.createElement("div");

     

       920
       920
       +
           importContainer.style.cssText = `

     

       921
       921
       +
             margin-top: 10px;

     

       922
       922
       +
             margin-bottom: 15px;

     

       923
       923
       +
           `;

     

       924
       924
       +
       

     

       925
       925
       +
           const importButton = document.createElement("button");

     

       926
       926
       +
           importButton.id = "importVerificationsBtn";

     

       927
       927
       +
           importButton.textContent = "Import Your Verifications";

     

       928
       928
       +
           importButton.style.cssText = `

     

       929
       929
       +
             background-color: #2D578D;

     

       930
       930
       +
             color: white;

     

       931
       931
       +
             border: none;

     

       932
       932
       +
             border-radius: 4px;

     

       933
       933
       +
             padding: 8px 15px;

     

       934
       934
       +
             cursor: pointer;

     

       935
       935
       +
             width: 100%;

     

       936
       936
       +
           `;

     

       937
       937
       +
       

     

       938
       938
       +
           importButton.addEventListener("click", importVerificationsFromSelf);

     

       939
       939
       +
           importContainer.appendChild(importButton);

     

       940
       940
       +
       

     

       941
       941
       +
           // Create trusted users list

     

       942
       942
       +
           const trustedUsersList = document.createElement("div");

     

       943
       943
       +
           trustedUsersList.id = "trustedUsersList";

     

       944
       944
       +
           trustedUsersList.style.cssText = `

     

       945
       945
       +
             margin-top: 15px;

     

       946
       946
       +
             border-top: 1px solid #eee;

     

       947
       947
       +
             padding-top: 15px;

     

       948
       948
       +
           `;

     

       949
       949
       +
       

     

       950
       950
       +
           // Create cache control buttons

     

       951
       951
       +
           const cacheControls = document.createElement("div");

     

       952
       952
       +
           cacheControls.style.cssText = `

     

       953
       953
       +
             margin-top: 15px;

     

       954
       954
       +
             padding-top: 15px;

     

       955
       955
       +
             border-top: 1px solid #eee;

     

       956
       956
       +
           `;

     

       957
       957
       +
       

     

       958
       958
       +
           const clearCacheButton = document.createElement("button");

     

       959
       959
       +
           clearCacheButton.textContent = "Clear Verification Cache";

     

       960
       960
       +
           clearCacheButton.style.cssText = `

     

       961
       961
       +
             padding: 8px 15px;

     

       962
       962
       +
             background-color: #735A5A;

     

       963
       963
       +
             color: white;

     

       964
       964
       +
             border: none;

     

       965
       965
       +
             border-radius: 4px;

     

       966
       966
       +
             cursor: pointer;

     

       967
       967
       +
             margin-right: 10px;

     

       968
       968
       +
           `;

     

       969
       969
       +
           clearCacheButton.addEventListener("click", () => {

     

       970
       970
       +
             clearCache();

     

       971
       971
       +
             alert(

     

       972
       972
       +
               "Verification cache cleared. Fresh data will be fetched on next check.",

     

       973
       973
       +
             );

     

       974
       974
       +
           });

     

       975
       975
       +
       

     

       976
       976
       +
           cacheControls.appendChild(clearCacheButton);

     

       977
       977
       +
       

     

       978
       978
       +
           // Create close button

     

       979
       979
       +
           const closeButton = document.createElement("button");

     

       980
       980
       +
           closeButton.textContent = "Close";

     

       981
       981
       +
           closeButton.style.cssText = `

     

       982
       982
       +
             margin-top: 20px;

     

       983
       983
       +
             padding: 8px 15px;

     

       984
       984
       +
             background-color: #473A3A;

     

       985
       985
       +
             border: none;

     

       986
       986
       +
             border-radius: 4px;

     

       987
       987
       +
             cursor: pointer;

     

       988
       988
       +
           `;

     

       989
       989
       +
       

     

       990
       990
       +
           // Assemble modal

     

       991
       991
       +
           modalContent.appendChild(modalHeader);

     

       992
       992
       +
           modalContent.appendChild(form);

     

       993
       993
       +
           modalContent.appendChild(importContainer);

     

       994
       994
       +
           modalContent.appendChild(trustedUsersList);

     

       995
       995
       +
           modalContent.appendChild(cacheControls);

     

       996
       996
       +
           modalContent.appendChild(closeButton);

     

       997
       997
       +
           settingsModal.appendChild(modalContent);

     

       998
       998
       +
       

     

       999
       999
       +
           // Add to document

     

       1000
       1000
       +
           document.body.appendChild(settingsModal);

     

       1001
       1001
       +
       

     

       1002
       1002
       +
           const userInput = document.getElementById("trustedUserInput");

     

       1003
       1003
       +
       

     

       1004
       1004
       +
           // Add input event for autocomplete

     

       1005
       1005
       +
           let debounceTimeout;

     

       1006
       1006
       +
           userInput.addEventListener("input", (e) => {

     

       1007
       1007
       +
             clearTimeout(debounceTimeout);

     

       1008
       1008
       +
             debounceTimeout = setTimeout(async () => {

     

       1009
       1009
       +
               const searchQuery = e.target.value.trim();

     

       1010
       1010
       +
               if (searchQuery.length >= 2) {

     

       1011
       1011
       +
                 const results = await searchUsers(searchQuery);

     

       1012
       1012
       +
                 showAutocompleteResults(results, userInput);

     

       1013
       1013
       +
               } else {

     

       1014
       1014
       +
                 const dropdown = document.getElementById("autocomplete-dropdown");

     

       1015
       1015
       +
                 if (dropdown) dropdown.remove();

     

       1016
       1016
       +
               }

     

       1017
       1017
       +
             }, 300); // Debounce for 300ms

     

       1018
       1018
       +
           });

     

       1019
       1019
       +
       

     

       1020
       1020
       +
           // Event listeners

     

       1021
       1021
       +
           closeButton.addEventListener("click", () => {

     

       1022
       1022
       +
             settingsModal.style.display = "none";

     

       1023
       1023
       +
           });

     

       1024
       1024
       +
       

     

       1025
       1025
       +
           // Function to add a user from the input field

     

       1026
       1026
       +
           const addUserFromInput = () => {

     

       1027
       1027
       +
             const input = document.getElementById("trustedUserInput");

     

       1028
       1028
       +
             const handle = input.value.trim();

     

       1029
       1029
       +
             if (handle) {

     

       1030
       1030
       +
               addTrustedUser(handle);

     

       1031
       1031
       +
               input.value = "";

     

       1032
       1032
       +
               updateTrustedUsersList();

     

       1033
       1033
       +
       

     

       1034
       1034
       +
               // Remove dropdown if present

     

       1035
       1035
       +
               const dropdown = document.getElementById("autocomplete-dropdown");

     

       1036
       1036
       +
               if (dropdown) dropdown.remove();

     

       1037
       1037
       +
             }

     

       1038
       1038
       +
           };

     

       1039
       1039
       +
       

     

       1040
       1040
       +
           // Add trusted user button event

     

       1041
       1041
       +
           document

     

       1042
       1042
       +
             .getElementById("addTrustedUserBtn")

     

       1043
       1043
       +
             .addEventListener("click", addUserFromInput);

     

       1044
       1044
       +
       

     

       1045
       1045
       +
           // Add keydown event to input for Enter key

     

       1046
       1046
       +
           userInput.addEventListener("keydown", (e) => {

     

       1047
       1047
       +
             if (e.key === "Enter") {

     

       1048
       1048
       +
               e.preventDefault();

     

       1049
       1049
       +
               addUserFromInput();

     

       1050
       1050
       +
             }

     

       1051
       1051
       +
           });

     

       1052
       1052
       +
       

     

       1053
       1053
       +
           // Close modal when clicking outside

     

       1054
       1054
       +
           settingsModal.addEventListener("click", (e) => {

     

       1055
       1055
       +
             if (e.target === settingsModal) {

     

       1056
       1056
       +
               settingsModal.style.display = "none";

     

       1057
       1057
       +
             }

     

       1058
       1058
       +
           });

     

       1059
       1059
       +
       

     

       1060
       1060
       +
           // Initialize the list

     

       1061
       1061
       +
           updateTrustedUsersList();

     

       1062
       1062
       +
         };

     

       1063
       1063
       +
       

     

       1064
       1064
       +
         // Function to check the current profile

     

       1065
       1065
       +
         const checkCurrentProfile = () => {

     

       1066
       1066
       +
           const currentUrl = window.location.href;

     

       1067
       1067
       +
           // Only trigger on profile pages

     

       1068
       1068
       +
           if (

     

       1069
       1069
       +
             currentUrl.match(/bsky\.app\/profile\/[^\/]+$/) ||

     

       1070
       1070
       +
             currentUrl.match(/bsky\.app\/profile\/[^\/]+\/follows/) ||

     

       1071
       1071
       +
             currentUrl.match(/bsky\.app\/profile\/[^\/]+\/followers/)

     

       1072
       1072
       +
           ) {

     

       1073
       1073
       +
             const handle = currentUrl.split("/profile/")[1].split("/")[0];

     

       1074
       1074
       +
             console.log("Detected profile page for:", handle);

     

       1075
       1075
       +
       

     

       1076
       1076
       +
             // Fetch user profile data

     

       1077
       1077
       +
             fetch(

     

       1078
       1078
       +
               `https://public.api.bsky.app/xrpc/com.atproto.repo.getRecord?repo=${handle}&collection=app.bsky.actor.profile&rkey=self`,

     

       1079
       1079
       +
             )

     

       1080
       1080
       +
               .then((response) => response.json())

     

       1081
       1081
       +
               .then((data) => {

     

       1082
       1082
       +
                 console.log("User profile data:", data);

     

       1083
       1083
       +
       

     

       1084
       1084
       +
                 // Extract the DID from the profile data

     

       1085
       1085
       +
                 const did = data.uri.split("/")[2];

     

       1086
       1086
       +
                 console.log("User DID:", did);

     

       1087
       1087
       +
       

     

       1088
       1088
       +
                 // Check if any trusted users have verified this profile using the DID

     

       1089
       1089
       +
                 checkTrustedUserVerifications(did);

     

       1090
       1090
       +
               })

     

       1091
       1091
       +
               .catch((error) => {

     

       1092
       1092
       +
                 console.error("Error checking profile:", error);

     

       1093
       1093
       +
               });

     

       1094
       1094
       +
       

     

       1095
       1095
       +
             console.log("Bluesky profile detected");

     

       1096
       1096
       +
           } else {

     

       1097
       1097
       +
             // Not on a profile page, reset state

     

       1098
       1098
       +
             currentProfileDid = null;

     

       1099
       1099
       +
             profileVerifiers = [];

     

       1100
       1100
       +
       

     

       1101
       1101
       +
             // Remove UI elements if present

     

       1102
       1102
       +
             const existingBadge = document.getElementById(

     

       1103
       1103
       +
               "user-trusted-verification-badge",

     

       1104
       1104
       +
             );

     

       1105
       1105
       +
             if (existingBadge) {

     

       1106
       1106
       +
               existingBadge.remove();

     

       1107
       1107
       +
             }

     

       1108
       1108
       +
           }

     

       1109
       1109
       +
         };

     

       1110
       1110
       +
       

     

       1111
       1111
       +
         const checkUserLinksOnPage = async () => {

     

       1112
       1112
       +
           // Look for profile links with handles

     

       1113
       1113
       +
           // Find all profile links and filter to get only one link per parent

     

       1114
       1114
       +
           const allProfileLinks = Array.from(

     

       1115
       1115
       +
             document.querySelectorAll('a[href^="/profile/"]:not(:has(*))'),

     

       1116
       1116
       +
           );

     

       1117
       1117
       +
       

     

       1118
       1118
       +
           // Use a Map to keep track of parent elements and their first child link

     

       1119
       1119
       +
           const parentMap = new Map();

     

       1120
       1120
       +
       

     

       1121
       1121
       +
           // For each link, store only the first one found for each parent

     

       1122
       1122
       +
           for (const link of allProfileLinks) {

     

       1123
       1123
       +
             const parent = link.parentElement;

     

       1124
       1124
       +
             if (parent && !parentMap.has(parent)) {

     

       1125
       1125
       +
               parentMap.set(parent, link);

     

       1126
       1126
       +
             }

     

       1127
       1127
       +
           }

     

       1128
       1128
       +
       

     

       1129
       1129
       +
           // Get only the first link for each parent

     

       1130
       1130
       +
           const profileLinks = Array.from(parentMap.values());

     

       1131
       1131
       +
       

     

       1132
       1132
       +
           if (profileLinks.length === 0) return;

     

       1133
       1133
       +
       

     

       1134
       1134
       +
           console.log(`Found ${profileLinks.length} possible user links on page`);

     

       1135
       1135
       +
       

     

       1136
       1136
       +
           // Process profile links to identify user containers

     

       1137
       1137
       +
           for (const link of profileLinks) {

     

       1138
       1138
       +
             try {

     

       1139
       1139
       +
               // Check if we already processed this link

     

       1140
       1140
       +
               if (link.getAttribute("data-verification-checked") === "true") continue;

     

       1141
       1141
       +
       

     

       1142
       1142
       +
               // Mark as checked

     

       1143
       1143
       +
               link.setAttribute("data-verification-checked", "true");

     

       1144
       1144
       +
       

     

       1145
       1145
       +
               // Extract handle from href

     

       1146
       1146
       +
               const handle = link.getAttribute("href").split("/profile/")[1];

     

       1147
       1147
       +
               if (!handle) continue;

     

       1148
       1148
       +
       

     

       1149
       1149
       +
               // check if there is anything after the handle

     

       1150
       1150
       +
               const handleTrailing = handle.split("/").length > 1;

     

       1151
       1151
       +
               if (handleTrailing) continue;

     

       1152
       1152
       +
       

     

       1153
       1153
       +
               // Find parent container that might contain the handle and verification icon

     

       1154
       1154
       +
               // Look for containers where this link is followed by another link with the same handle

     

       1155
       1155
       +
               const parent = link.parentElement;

     

       1156
       1156
       +
       

     

       1157
       1157
       +
               // If we found a container with the verification icon

     

       1158
       1158
       +
               if (parent) {

     

       1159
       1159
       +
                 // Check if this user already has our verification badge

     

       1160
       1160
       +
                 if (parent.querySelector(".trusted-user-inline-badge")) continue;

     

       1161
       1161
       +
       

     

       1162
       1162
       +
                 try {

     

       1163
       1163
       +
                   // Fetch user profile data to get DID

     

       1164
       1164
       +
                   const response = await fetch(

     

       1165
       1165
       +
                     `https://public.api.bsky.app/xrpc/com.atproto.repo.getRecord?repo=${handle}&collection=app.bsky.actor.profile&rkey=self`,

     

       1166
       1166
       +
                   );

     

       1167
       1167
       +
                   const data = await response.json();

     

       1168
       1168
       +
       

     

       1169
       1169
       +
                   // Extract the DID from the profile data

     

       1170
       1170
       +
                   const did = data.uri.split("/")[2];

     

       1171
       1171
       +
       

     

       1172
       1172
       +
                   // Check if this user is verified by our trusted users

     

       1173
       1173
       +
                   const trustedUsers = getTrustedUsers();

     

       1174
       1174
       +
                   let isVerified = false;

     

       1175
       1175
       +
                   const verifiers = [];

     

       1176
       1176
       +
       

     

       1177
       1177
       +
                   // Check cache first for each trusted user

     

       1178
       1178
       +
                   for (const trustedUser of trustedUsers) {

     

       1179
       1179
       +
                     const cachedData = getCachedVerifications(trustedUser);

     

       1180
       1180
       +
       

     

       1181
       1181
       +
                     if (cachedData && isCacheValid(cachedData)) {

     

       1182
       1182
       +
                       // Use cached verification data

     

       1183
       1183
       +
                       const records = cachedData.records;

     

       1184
       1184
       +
       

     

       1185
       1185
       +
                       for (const record of records) {

     

       1186
       1186
       +
                         if (record.value && record.value.subject === did) {

     

       1187
       1187
       +
                           isVerified = true;

     

       1188
       1188
       +
                           verifiers.push(trustedUser);

     

       1189
       1189
       +
                           break;

     

       1190
       1190
       +
                         }

     

       1191
       1191
       +
                       }

     

       1192
       1192
       +
                     }

     

       1193
       1193
       +
                   }

     

       1194
       1194
       +
       

     

       1195
       1195
       +
                   // If verified, add a small badge

     

       1196
       1196
       +
                   if (isVerified && verifiers.length > 0) {

     

       1197
       1197
       +
                     // Create a badge element

     

       1198
       1198
       +
                     const smallBadge = document.createElement("span");

     

       1199
       1199
       +
                     smallBadge.className = "trusted-user-inline-badge";

     

       1200
       1200
       +
       

     

       1201
       1201
       +
                     // Get user badge preferences

     

       1202
       1202
       +
                     const badgeType = getBadgeType();

     

       1203
       1203
       +
                     const badgeColor = getBadgeColor();

     

       1204
       1204
       +
       

     

       1205
       1205
       +
                     smallBadge.innerHTML = getBadgeContent(badgeType);

     

       1206
       1206
       +
       

     

       1207
       1207
       +
                     // Create tooltip text with all verifiers

     

       1208
       1208
       +
                     const verifiersText =

     

       1209
       1209
       +
                       verifiers.length > 1

     

       1210
       1210
       +
                         ? `Verified by: ${verifiers.join(", ")}`

     

       1211
       1211
       +
                         : `Verified by ${verifiers[0]}`;

     

       1212
       1212
       +
       

     

       1213
       1213
       +
                     smallBadge.title = verifiersText;

     

       1214
       1214
       +
                     smallBadge.style.cssText = `

     

       1215
       1215
       +
                       background-color: ${badgeColor};

     

       1216
       1216
       +
                       color: white;

     

       1217
       1217
       +
                       border-radius: 50%;

     

       1218
       1218
       +
                       width: 16px;

     

       1219
       1219
       +
                       height: 16px;

     

       1220
       1220
       +
                       font-size: 11px;

     

       1221
       1221
       +
                       font-weight: bold;

     

       1222
       1222
       +
                       cursor: help;

     

       1223
       1223
       +
                       display: inline-flex;

     

       1224
       1224
       +
                       align-items: center;

     

       1225
       1225
       +
                       justify-content: center;

     

       1226
       1226
       +
                       margin-left: 4px;

     

       1227
       1227
       +
                     `;

     

       1228
       1228
       +
       

     

       1229
       1229
       +
                     // Add click event to show verifiers

     

       1230
       1230
       +
                     smallBadge.addEventListener("click", (e) => {

     

       1231
       1231
       +
                       e.stopPropagation();

     

       1232
       1232
       +
                       showVerifiersPopup(verifiers);

     

       1233
       1233
       +
                     });

     

       1234
       1234
       +
       

     

       1235
       1235
       +
                     // Insert badge after the SVG element

     

       1236
       1236
       +
                     parent.firstChild.after(smallBadge);

     

       1237
       1237
       +
                     parent.style.flexDirection = "row";

     

       1238
       1238
       +
                     parent.style.alignItems = "center";

     

       1239
       1239
       +
       

     

       1240
       1240
       +
                     // Look for verification SVG icon in the parent and remove it if it exists

     

       1241
       1241
       +
                     const badgeSvgIcon = Array.from(parent.childNodes).find(

     

       1242
       1242
       +
                       (node) =>

     

       1243
       1243
       +
                         node.nodeType === Node.ELEMENT_NODE &&

     

       1244
       1244
       +
                         node.tagName === "DIV" &&

     

       1245
       1245
       +
                         node.querySelector("svg"),

     

       1246
       1246
       +
                     );

     

       1247
       1247
       +
                     if (badgeSvgIcon) {

     

       1248
       1248
       +
                       badgeSvgIcon.remove();

     

       1249
       1249
       +
                     }

     

       1250
       1250
       +
                   }

     

       1251
       1251
       +
                 } catch (error) {

     

       1252
       1252
       +
                   console.error(`Error checking verification for ${handle}:`, error);

     

       1253
       1253
       +
                 }

     

       1254
       1254
       +
               }

     

       1255
       1255
       +
             } catch (error) {

     

       1256
       1256
       +
               console.error("Error processing profile link:", error);

     

       1257
       1257
       +
             }

     

       1258
       1258
       +
           }

     

       1259
       1259
       +
         };

     

       1260
       1260
       +
       

     

       1261
       1261
       +
         const observeContentChanges = () => {

     

       1262
       1262
       +
           // Use a debounced function to check for new user links

     

       1263
       1263
       +
           const debouncedCheck = () => {

     

       1264
       1264
       +
             clearTimeout(window.userLinksCheckTimeout);

     

       1265
       1265
       +
             window.userLinksCheckTimeout = setTimeout(() => {

     

       1266
       1266
       +
               checkUserLinksOnPage();

     

       1267
       1267
       +
             }, 300);

     

       1268
       1268
       +
           };

     

       1269
       1269
       +
       

     

       1270
       1270
       +
           // Create a mutation observer that watches for DOM changes

     

       1271
       1271
       +
           const observer = new MutationObserver((mutations) => {

     

       1272
       1272
       +
             let hasRelevantChanges = false;

     

       1273
       1273
       +
       

     

       1274
       1274
       +
             // Check if any mutations involve adding new nodes

     

       1275
       1275
       +
             for (const mutation of mutations) {

     

       1276
       1276
       +
               if (mutation.addedNodes.length > 0) {

     

       1277
       1277
       +
                 for (const node of mutation.addedNodes) {

     

       1278
       1278
       +
                   if (node.nodeType === Node.ELEMENT_NODE) {

     

       1279
       1279
       +
                     // Check if this element or its children might contain profile links

     

       1280
       1280
       +
                     if (

     

       1281
       1281
       +
                       node.querySelector('a[href^="/profile/"]') ||

     

       1282
       1282
       +
                       (node.tagName === "A" &&

     

       1283
       1283
       +
                         node.getAttribute("href")?.startsWith("/profile/"))

     

       1284
       1284
       +
                     ) {

     

       1285
       1285
       +
                       hasRelevantChanges = true;

     

       1286
       1286
       +
                       break;

     

       1287
       1287
       +
                     }

     

       1288
       1288
       +
                   }

     

       1289
       1289
       +
                 }

     

       1290
       1290
       +
               }

     

       1291
       1291
       +
               if (hasRelevantChanges) break;

     

       1292
       1292
       +
             }

     

       1293
       1293
       +
       

     

       1294
       1294
       +
             if (hasRelevantChanges) {

     

       1295
       1295
       +
               debouncedCheck();

     

       1296
       1296
       +
             }

     

       1297
       1297
       +
           });

     

       1298
       1298
       +
       

     

       1299
       1299
       +
           // Observe the entire document for content changes that might include profile links

     

       1300
       1300
       +
           observer.observe(document.body, { childList: true, subtree: true });

     

       1301
       1301
       +
       

     

       1302
       1302
       +
           // Also check periodically for posts that might have been loaded but not caught by the observer

     

       1303
       1303
       +
           setInterval(debouncedCheck, 5000);

     

       1304
       1304
       +
         };

     

       1305
       1305
       +
       

     

       1306
       1306
       +
         // Wait for DOM to be fully loaded before initializing

     

       1307
       1307
       +
         document.addEventListener("DOMContentLoaded", () => {

     

       1308
       1308
       +
           // Initial check for user links

     

       1309
       1309
       +
           checkUserLinksOnPage();

     

       1310
       1310
       +
       

     

       1311
       1311
       +
           // Initial check

     

       1312
       1312
       +
           setTimeout(checkCurrentProfile, 2000);

     

       1313
       1313
       +
       

     

       1314
       1314
       +
           // Add settings button if we're on the settings page

     

       1315
       1315
       +
           if (window.location.href.includes("bsky.app/settings")) {

     

       1316
       1316
       +
             // Wait for the content-and-media link to appear before adding our button

     

       1317
       1317
       +
             const waitForSettingsLink = setInterval(() => {

     

       1318
       1318
       +
               const contentMediaLink = document.querySelector(

     

       1319
       1319
       +
                 'a[href="/settings/content-and-media"]',

     

       1320
       1320
       +
               );

     

       1321
       1321
       +
               if (contentMediaLink) {

     

       1322
       1322
       +
                 clearInterval(waitForSettingsLink);

     

       1323
       1323
       +
                 addSettingsButton();

     

       1324
       1324
       +
               }

     

       1325
       1325
       +
             }, 200);

     

       1326
       1326
       +
           }

     

       1327
       1327
       +
         });

     

       1328
       1328
       +
       

     

       1329
       1329
       +
         // Start observing for content changes to detect newly loaded posts

     

       1330
       1330
       +
         observeContentChanges();

     

       1331
       1331
       +
       

     

       1332
       1332
       +
         // Set up a MutationObserver to watch for URL changes

     

       1333
       1333
       +
         const observeUrlChanges = () => {

     

       1334
       1334
       +
           let lastUrl = location.href;

     

       1335
       1335
       +
       

     

       1336
       1336
       +
           const observer = new MutationObserver(() => {

     

       1337
       1337
       +
             if (location.href !== lastUrl) {

     

       1338
       1338
       +
               const oldUrl = lastUrl;

     

       1339
       1339
       +
               lastUrl = location.href;

     

       1340
       1340
       +
               console.log("URL changed from:", oldUrl, "to:", location.href);

     

       1341
       1341
       +
       

     

       1342
       1342
       +
               // Reset current profile DID

     

       1343
       1343
       +
               currentProfileDid = null;

     

       1344
       1344
       +
               profileVerifiers = [];

     

       1345
       1345
       +
       

     

       1346
       1346
       +
               // Clean up UI elements

     

       1347
       1347
       +
               const existingBadge = document.getElementById(

     

       1348
       1348
       +
                 "user-trusted-verification-badge",

     

       1349
       1349
       +
               );

     

       1350
       1350
       +
               if (existingBadge) {

     

       1351
       1351
       +
                 existingBadge.remove();

     

       1352
       1352
       +
               }

     

       1353
       1353
       +
       

     

       1354
       1354
       +
               // Check if we're on a profile page now

     

       1355
       1355
       +
               setTimeout(checkCurrentProfile, 500); // Small delay to ensure DOM has updated

     

       1356
       1356
       +
       

     

       1357
       1357
       +
               if (window.location.href.includes("bsky.app/settings")) {

     

       1358
       1358
       +
                 // Give the page a moment to fully load

     

       1359
       1359
       +
                 setTimeout(addSettingsButton, 200);

     

       1360
       1360
       +
               }

     

       1361
       1361
       +
             }

     

       1362
       1362
       +
           });

     

       1363
       1363
       +
       

     

       1364
       1364
       +
           observer.observe(document, { subtree: true, childList: true });

     

       1365
       1365
       +
         };

     

       1366
       1366
       +
       

     

       1367
       1367
       +
         // Start observing for URL changes

     

       1368
       1368
       +
         observeUrlChanges();

     

       1369
       1369
       +
       })();

+63

bomb.ts

···

       1
       1
       +
       import { serve } from "bun";

     

       2
       2
       +
       import { file } from "bun";

     

       3
       3
       +
       

     

       4
       4
       +
       const PORT = Number.parseInt(process.env.PORT || "3000");

     

       5
       5
       +
       const ZIP_FILE_PATH = "./bigboy.gz"; // Path to your compressed file

     

       6
       6
       +
       

     

       7
       7
       +
       serve({

     

       8
       8
       +
         port: PORT,

     

       9
       9
       +
         async fetch(req) {

     

       10
       10
       +
           const url = new URL(req.url);

     

       11
       11
       +
       

     

       12
       12
       +
           // Only serve the file at the /download endpoint

     

       13
       13
       +
           if (url.pathname === "/download") {

     

       14
       14
       +
             try {

     

       15
       15
       +
               // Use Bun's file API to get the compressed file

     

       16
       16
       +
               const compressedFile = file(ZIP_FILE_PATH);

     

       17
       17
       +
               const fileSize = compressedFile.size;

     

       18
       18
       +
       

     

       19
       19
       +
               // Set headers to trigger browser decompression

     

       20
       20
       +
               const headers = new Headers();

     

       21
       21
       +
               headers.set("Content-Type", "application/octet-stream");

     

       22
       22
       +
               headers.set("Content-Length", fileSize.toString());

     

       23
       23
       +
               headers.set("Content-Encoding", "gzip");

     

       24
       24
       +
               headers.set("Content-Disposition", `attachment; filename="bomb.gz"`);

     

       25
       25
       +
               headers.set("Cache-Control", "no-store, max-age=0");

     

       26
       26
       +
               headers.set("ETag", `"${Math.random().toString(36).substring(2, 15)}"`);

     

       27
       27
       +
               headers.set("X-Compression-Ratio", "666:1");

     

       28
       28
       +
       

     

       29
       29
       +
               return new Response(compressedFile.stream(), {

     

       30
       30
       +
                 status: 200,

     

       31
       31
       +
                 headers: headers,

     

       32
       32
       +
               });

     

       33
       33
       +
             } catch (error) {

     

       34
       34
       +
               console.error("Error serving file:", error);

     

       35
       35
       +
               return new Response("Error serving file", { status: 500 });

     

       36
       36
       +
             }

     

       37
       37
       +
           }

     

       38
       38
       +
       

     

       39
       39
       +
           // Serve a simple HTML page with a download link

     

       40
       40
       +
           return new Response(

     

       41
       41
       +
             `

     

       42
       42
       +
             <!DOCTYPE html>

     

       43
       43
       +
             <html>

     

       44
       44
       +
               <head>

     

       45
       45
       +
                 <title>File Download</title>

     

       46
       46
       +
               </head>

     

       47
       47
       +
               <body>

     

       48
       48
       +
                 <h1>Compressed File Server</h1>

     

       49
       49
       +
                 <p>Click below to download the file (104MB compressed, 100GB uncompressed)</p>

     

       50
       50
       +
                 <a href="/download">Download File</a>

     

       51
       51
       +
               </body>

     

       52
       52
       +
             </html>

     

       53
       53
       +
           `,

     

       54
       54
       +
             {

     

       55
       55
       +
               headers: {

     

       56
       56
       +
                 "Content-Type": "text/html",

     

       57
       57
       +
               },

     

       58
       58
       +
             },

     

       59
       59
       +
           );

     

       60
       60
       +
         },

     

       61
       61
       +
       });

     

       62
       62
       +
       

     

       63
       63
       +
       console.log(`Server running at http://localhost:${PORT}`);

+46

bun.lock

···

       4
       4
        
           "": {

     

       5
       5
        
             "name": "bunplayground",

     

       6
       6
        
             "dependencies": {

     

       7
       7
       +
               "@cap.js/middleware-elysia": "^0.0.1",

     

       8
       8
       +
               "elysia": "^1.3.3",

     

       7
       9
        
               "terser": "^5.39.0",

     

       8
       10
        
             },

     

       9
       11
        
             "devDependencies": {

     
···

       15
       17
        
           },

     

       16
       18
        
         },

     

       17
       19
        
         "packages": {

     

       20
       20
       +
           "@cap.js/middleware-elysia": ["@cap.js/middleware-elysia@0.0.1", "", { "dependencies": { "@cap.js/server": "^1.0.15", "elysia": "^1.3.3" } }, "sha512-cIGggp+gF+m3qr8DZ5Vcx9/+xohn616611X4uODDdOrgN7qhA57bXjKxEQS8+fo1gMGTMR8qomdUqI0TRJ3YNw=="],

     

       21
       21
       +
       

     

       22
       22
       +
           "@cap.js/server": ["@cap.js/server@1.0.15", "", { "dependencies": { "@types/node": "^22.14.1", "typescript": "^5.8.3" } }, "sha512-mcDbHAL4ar5O4gnDE+62ZPeXhLXxd1KKHzJCsZfn81HY8Fgo5ousxYCnzhsLfki5sH6sO6jpNtS4MZXlKDq+fA=="],

     

       23
       23
       +
       

     

       18
       24
        
           "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.8", "", { "dependencies": { "@jridgewell/set-array": "^1.2.1", "@jridgewell/sourcemap-codec": "^1.4.10", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA=="],

     

       19
       25
        
       

     

       20
       26
        
           "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],

     
···

       26
       32
        
           "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.0", "", {}, "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ=="],

     

       27
       33
        
       

     

       28
       34
        
           "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.25", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ=="],

     

       35
       35
       +
       

     

       36
       36
       +
           "@sinclair/typebox": ["@sinclair/typebox@0.34.33", "", {}, "sha512-5HAV9exOMcXRUxo+9iYB5n09XxzCXnfy4VTNW4xnDv+FgjzAGY989C28BIdljKqmF+ZltUwujE3aossvcVtq6g=="],

     

       37
       37
       +
       

     

       38
       38
       +
           "@tokenizer/inflate": ["@tokenizer/inflate@0.2.7", "", { "dependencies": { "debug": "^4.4.0", "fflate": "^0.8.2", "token-types": "^6.0.0" } }, "sha512-MADQgmZT1eKjp06jpI2yozxaU9uVs4GzzgSL+uEq7bVcJ9V1ZXQkeGNql1fsSI0gMy1vhvNTNbUqrx+pZfJVmg=="],

     

       39
       39
       +
       

     

       40
       40
       +
           "@tokenizer/token": ["@tokenizer/token@0.3.0", "", {}, "sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A=="],

     

       29
       41
        
       

     

       30
       42
        
           "@types/bun": ["@types/bun@1.2.6", "", { "dependencies": { "bun-types": "1.2.6" } }, "sha512-fY9CAmTdJH1Llx7rugB0FpgWK2RKuHCs3g2cFDYXUutIy1QGiPQxKkGY8owhfZ4MXWNfxwIbQLChgH5gDsY7vw=="],

     

       31
       43
        
       

     
···

       41
       53
        
       

     

       42
       54
        
           "commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="],

     

       43
       55
        
       

     

       56
       56
       +
           "cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],

     

       57
       57
       +
       

     

       58
       58
       +
           "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],

     

       59
       59
       +
       

     

       60
       60
       +
           "elysia": ["elysia@1.3.3", "", { "dependencies": { "cookie": "^1.0.2", "exact-mirror": "0.1.2", "fast-decode-uri-component": "^1.0.1" }, "optionalDependencies": { "@sinclair/typebox": "^0.34.33", "openapi-types": "^12.1.3" }, "peerDependencies": { "file-type": ">= 20.0.0", "typescript": ">= 5.0.0" } }, "sha512-x6a89d4h0xX9TB0CSGkUuKNqIK776HBJw0WHtK1B3ViQqZijsLnOor6be/7TwVl8MG6m59NHGHbmbBS6lnCXSw=="],

     

       61
       61
       +
       

     

       62
       62
       +
           "exact-mirror": ["exact-mirror@0.1.2", "", { "peerDependencies": { "@sinclair/typebox": "^0.34.15" }, "optionalPeers": ["@sinclair/typebox"] }, "sha512-wFCPCDLmHbKGUb8TOi/IS7jLsgR8WVDGtDK3CzcB4Guf/weq7G+I+DkXiRSZfbemBFOxOINKpraM6ml78vo8Zw=="],

     

       63
       63
       +
       

     

       64
       64
       +
           "fast-decode-uri-component": ["fast-decode-uri-component@1.0.1", "", {}, "sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg=="],

     

       65
       65
       +
       

     

       66
       66
       +
           "fflate": ["fflate@0.8.2", "", {}, "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A=="],

     

       67
       67
       +
       

     

       68
       68
       +
           "file-type": ["file-type@21.0.0", "", { "dependencies": { "@tokenizer/inflate": "^0.2.7", "strtok3": "^10.2.2", "token-types": "^6.0.0", "uint8array-extras": "^1.4.0" } }, "sha512-ek5xNX2YBYlXhiUXui3D/BXa3LdqPmoLJ7rqEx2bKJ7EAUEfmXgW0Das7Dc6Nr9MvqaOnIqiPV0mZk/r/UpNAg=="],

     

       69
       69
       +
       

     

       70
       70
       +
           "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],

     

       71
       71
       +
       

     

       72
       72
       +
           "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],

     

       73
       73
       +
       

     

       74
       74
       +
           "openapi-types": ["openapi-types@12.1.3", "", {}, "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw=="],

     

       75
       75
       +
       

     

       76
       76
       +
           "peek-readable": ["peek-readable@7.0.0", "", {}, "sha512-nri2TO5JE3/mRryik9LlHFT53cgHfRK0Lt0BAZQXku/AW3E6XLt2GaY8siWi7dvW/m1z0ecn+J+bpDa9ZN3IsQ=="],

     

       77
       77
       +
       

     

       44
       78
        
           "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],

     

       45
       79
        
       

     

       46
       80
        
           "source-map-support": ["source-map-support@0.5.21", "", { "dependencies": { "buffer-from": "^1.0.0", "source-map": "^0.6.0" } }, "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w=="],

     

       47
       81
        
       

     

       82
       82
       +
           "strtok3": ["strtok3@10.2.2", "", { "dependencies": { "@tokenizer/token": "^0.3.0", "peek-readable": "^7.0.0" } }, "sha512-Xt18+h4s7Z8xyZ0tmBoRmzxcop97R4BAh+dXouUDCYn+Em+1P3qpkUfI5ueWLT8ynC5hZ+q4iPEmGG1urvQGBg=="],

     

       83
       83
       +
       

     

       48
       84
        
           "terser": ["terser@5.39.0", "", { "dependencies": { "@jridgewell/source-map": "^0.3.3", "acorn": "^8.8.2", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, "bin": { "terser": "bin/terser" } }, "sha512-LBAhFyLho16harJoWMg/nZsQYgTrg5jXOn2nCYjRUcZZEdE3qa2zb8QEDRUGVZBW4rlazf2fxkg8tztybTaqWw=="],

     

       85
       85
       +
       

     

       86
       86
       +
           "token-types": ["token-types@6.0.0", "", { "dependencies": { "@tokenizer/token": "^0.3.0", "ieee754": "^1.2.1" } }, "sha512-lbDrTLVsHhOMljPscd0yitpozq7Ga2M5Cvez5AjGg8GASBjtt6iERCAJ93yommPmz62fb45oFIXHEZ3u9bfJEA=="],

     

       49
       87
        
       

     

       50
       88
        
           "typescript": ["typescript@5.8.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ=="],

     

       51
       89
        
       

     

       90
       90
       +
           "uint8array-extras": ["uint8array-extras@1.4.0", "", {}, "sha512-ZPtzy0hu4cZjv3z5NW9gfKnNLjoz4y6uv4HlelAjDK7sY/xOkKZv9xK/WQpcsBB3jEybChz9DPC2U/+cusjJVQ=="],

     

       91
       91
       +
       

     

       52
       92
        
           "undici-types": ["undici-types@6.20.0", "", {}, "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg=="],

     

       93
       93
       +
       

     

       94
       94
       +
           "@cap.js/server/@types/node": ["@types/node@22.15.29", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-LNdjOkUDlU1RZb8e1kOIUpN1qQUlzGkEtbVNo53vbrwDg5om6oduhm4SiUaPW5ASTXhAiP0jInWG8Qx9fVlOeQ=="],

     

       95
       95
       +
       

     

       96
       96
       +
           "@cap.js/server/typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],

     

       97
       97
       +
       

     

       98
       98
       +
           "@cap.js/server/@types/node/undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],

     

       53
       99
        
         }

     

       54
       100
        
       }

+17

cap.ts

···

       1
       1
       +
       import { Elysia, file } from "elysia";

     

       2
       2
       +
       import { capMiddleware } from "@cap.js/middleware-elysia";

     

       3
       3
       +
       

     

       4
       4
       +
       new Elysia()

     

       5
       5
       +
         .use(

     

       6
       6
       +
           capMiddleware({

     

       7
       7
       +
             token_validity_hours: 0, // how long the token is valid for

     

       8
       8
       +
             tokens_store_path: ".data/tokensList.json",

     

       9
       9
       +
             token_size: 1600, // token size in bytes

     

       10
       10
       +
             scoping: "scoped", // 'global' | 'scoped'

     

       11
       11
       +
           }),

     

       12
       12
       +
         )

     

       13
       13
       +
         .get("/", () => "Hello Elysia!")

     

       14
       14
       +
         .listen(3000);

     

       15
       15
       +
       

     

       16
       16
       +
       console.log("Server started on port 3000");

     

       17
       17
       +
       console.log("http://localhost:3000");

package.json

···

       9
       9
        
           "typescript": "^5"

     

       10
       10
        
         },

     

       11
       11
        
         "dependencies": {

     

       12
       12
       +
           "@cap.js/middleware-elysia": "^0.0.1",

     

       13
       13
       +
           "elysia": "^1.3.3",

     

       12
       14
        
           "terser": "^5.39.0"

     

       13
       15
        
         }

     

       14
       16
        
       }

+217

slack-http-allowed.user.js

···

       1
       1
       +
       // ==UserScript==

     

       2
       2
       +
       // @name         Slack Allow HTTP OAuth urls

     

       3
       3
       +
       // @namespace    https://tangled.sh/@dunkirk.sh/bunplayground/slack-http-allowed

     

       4
       4
       +
       // @version      0.1

     

       5
       5
       +
       // @description

     

       6
       6
       +
       // @author       Kieran Klukas

     

       7
       7
       +
       // @match        https://api.slack.com/apps/*/oauth*

     

       8
       8
       +
       // @grant        none

     

       9
       9
       +
       // @run-at       document-end

     

       10
       10
       +
       // ==/UserScript==

     

       11
       11
       +
       

     

       12
       12
       +
       (() => {

     

       13
       13
       +
         // Track HTTP inputs to avoid redundant processing

     

       14
       14
       +
         const httpInputs = new Set();

     

       15
       15
       +
       

     

       16
       16
       +
         // Add CSS to style the editor table layout

     

       17
       17
       +
         function addCustomStyles() {

     

       18
       18
       +
           const styleEl = document.createElement("style");

     

       19
       19
       +
           styleEl.textContent = `

     

       20
       20
       +
             .p-url_table_editor__actions {

     

       21
       21
       +
               width: 176px !important;

     

       22
       22
       +
             }

     

       23
       23
       +
             .p-url_table_editor__fields {

     

       24
       24
       +
               width: calc(100% - 176px) !important;

     

       25
       25
       +
             }

     

       26
       26
       +
           `;

     

       27
       27
       +
           document.head.appendChild(styleEl);

     

       28
       28
       +
         }

     

       29
       29
       +
       

     

       30
       30
       +
         function watchForHTTPEntries() {

     

       31
       31
       +
           const urlInputs = document.querySelectorAll(

     

       32
       32
       +
             "[data-url-table-editor-input]",

     

       33
       33
       +
           );

     

       34
       34
       +
       

     

       35
       35
       +
           // Add event listeners to each input field that doesn't already have one

     

       36
       36
       +
           for (const input of urlInputs) {

     

       37
       37
       +
             if (input.hasHttpListener) continue;

     

       38
       38
       +
       

     

       39
       39
       +
             input.hasHttpListener = true;

     

       40
       40
       +
             input.addEventListener("input", function () {

     

       41
       41
       +
               const row = this.closest("[data-row]");

     

       42
       42
       +
               if (!row) return;

     

       43
       43
       +
       

     

       44
       44
       +
               const saveButton = row.querySelector(

     

       45
       45
       +
                 '[data-js-url-editor="save-create"]',

     

       46
       46
       +
               );

     

       47
       47
       +
               if (!saveButton) return;

     

       48
       48
       +
       

     

       49
       49
       +
               // Check if input contains http:// (non-https URL)

     

       50
       50
       +
               if (this.value.trim().startsWith("http://")) {

     

       51
       51
       +
                 // Make the button sassy and green

     

       52
       52
       +
                 saveButton.classList.remove("disabled");

     

       53
       53
       +
                 saveButton.removeAttribute("disabled");

     

       54
       54
       +
                 saveButton.textContent = "add 😈";

     

       55
       55
       +
       

     

       56
       56
       +
                 // Add to tracking set

     

       57
       57
       +
                 httpInputs.add(this);

     

       58
       58
       +
               } else {

     

       59
       59
       +
                 // Reset to default state if not http://

     

       60
       60
       +
                 saveButton.textContent = "Add";

     

       61
       61
       +
       

     

       62
       62
       +
                 // Remove from tracking set

     

       63
       63
       +
                 httpInputs.delete(this);

     

       64
       64
       +
       

     

       65
       65
       +
                 // Only re-disable if empty (assuming that's the original logic)

     

       66
       66
       +
                 if (!this.value.trim()) {

     

       67
       67
       +
                   saveButton.classList.add("disabled");

     

       68
       68
       +
                   saveButton.setAttribute("disabled", "");

     

       69
       69
       +
                 }

     

       70
       70
       +
               }

     

       71
       71
       +
             });

     

       72
       72
       +
           }

     

       73
       73
       +
         }

     

       74
       74
       +
       

     

       75
       75
       +
         // Function to specifically fix HTTP buttons that might have been disabled

     

       76
       76
       +
         function fixHttpButtons() {

     

       77
       77
       +
           // Only process inputs we know have HTTP URLs

     

       78
       78
       +
           for (const input of httpInputs) {

     

       79
       79
       +
             if (!input.value.trim().startsWith("http://")) {

     

       80
       80
       +
               httpInputs.delete(input);

     

       81
       81
       +
               continue;

     

       82
       82
       +
             }

     

       83
       83
       +
       

     

       84
       84
       +
             const row = input.closest("[data-row]");

     

       85
       85
       +
             if (!row) {

     

       86
       86
       +
               httpInputs.delete(input);

     

       87
       87
       +
               continue;

     

       88
       88
       +
             }

     

       89
       89
       +
       

     

       90
       90
       +
             const saveButton = row.querySelector(

     

       91
       91
       +
               '[data-js-url-editor="save-create"]',

     

       92
       92
       +
             );

     

       93
       93
       +
             if (!saveButton) {

     

       94
       94
       +
               httpInputs.delete(input);

     

       95
       95
       +
               continue;

     

       96
       96
       +
             }

     

       97
       97
       +
       

     

       98
       98
       +
             // Force the button to stay enabled

     

       99
       99
       +
             saveButton.classList.remove("disabled");

     

       100
       100
       +
             saveButton.removeAttribute("disabled");

     

       101
       101
       +
             saveButton.textContent = "add 😈";

     

       102
       102
       +
           }

     

       103
       103
       +
         }

     

       104
       104
       +
       

     

       105
       105
       +
         // Watch for attribute changes on buttons to detect when they're disabled again

     

       106
       106
       +
         function watchButtonAttributes() {

     

       107
       107
       +
           const buttonObserver = new window.MutationObserver((mutations) => {

     

       108
       108
       +
             for (const mutation of mutations) {

     

       109
       109
       +
               if (

     

       110
       110
       +
                 mutation.type === "attributes" &&

     

       111
       111
       +
                 (mutation.attributeName === "disabled" ||

     

       112
       112
       +
                   mutation.attributeName === "class")

     

       113
       113
       +
               ) {

     

       114
       114
       +
                 const button = mutation.target;

     

       115
       115
       +
                 const row = button.closest("[data-row]");

     

       116
       116
       +
                 if (!row) continue;

     

       117
       117
       +
       

     

       118
       118
       +
                 const input = row.querySelector("[data-url-table-editor-input]");

     

       119
       119
       +
                 if (!input || !input.value.trim().startsWith("http://")) continue;

     

       120
       120
       +
       

     

       121
       121
       +
                 // This is an HTTP input with a button that was just disabled

     

       122
       122
       +
                 // Re-enable it immediately

     

       123
       123
       +
                 if (

     

       124
       124
       +
                   button.classList.contains("disabled") ||

     

       125
       125
       +
                   button.hasAttribute("disabled")

     

       126
       126
       +
                 ) {

     

       127
       127
       +
                   button.classList.remove("disabled");

     

       128
       128
       +
                   button.removeAttribute("disabled");

     

       129
       129
       +
                   button.textContent = "add 😈";

     

       130
       130
       +
                 }

     

       131
       131
       +
               }

     

       132
       132
       +
             }

     

       133
       133
       +
           });

     

       134
       134
       +
       

     

       135
       135
       +
           // Observe all save buttons for attribute changes

     

       136
       136
       +
           const saveButtons = document.querySelectorAll(

     

       137
       137
       +
             '[data-js-url-editor="save-create"]',

     

       138
       138
       +
           );

     

       139
       139
       +
           for (const button of saveButtons) {

     

       140
       140
       +
             buttonObserver.observe(button, { attributes: true });

     

       141
       141
       +
           }

     

       142
       142
       +
       

     

       143
       143
       +
           return buttonObserver;

     

       144
       144
       +
         }

     

       145
       145
       +
       

     

       146
       146
       +
         // Run the CSS additions immediately

     

       147
       147
       +
         addCustomStyles();

     

       148
       148
       +
       

     

       149
       149
       +
         // Run the function immediately

     

       150
       150
       +
         watchForHTTPEntries();

     

       151
       151
       +
         fixHttpButtons();

     

       152
       152
       +
         const buttonObserver = watchButtonAttributes();

     

       153
       153
       +
       

     

       154
       154
       +
         // Then run it again after a delay to ensure DOM is fully loaded

     

       155
       155
       +
         setTimeout(() => {

     

       156
       156
       +
           watchForHTTPEntries();

     

       157
       157
       +
           fixHttpButtons();

     

       158
       158
       +
         }, 1000);

     

       159
       159
       +
       

     

       160
       160
       +
         // Run the button fix less frequently to reduce browser lag

     

       161
       161
       +
         setInterval(fixHttpButtons, 1000);

     

       162
       162
       +
       

     

       163
       163
       +
         // Observer for new inputs

     

       164
       164
       +
         const inputObserver = new window.MutationObserver((mutations) => {

     

       165
       165
       +
           // Throttle the observer callback

     

       166
       166
       +
           if (inputObserver.isProcessing) return;

     

       167
       167
       +
           inputObserver.isProcessing = true;

     

       168
       168
       +
       

     

       169
       169
       +
           setTimeout(() => {

     

       170
       170
       +
             let hasNewInputs = false;

     

       171
       171
       +
             let hasNewButtons = false;

     

       172
       172
       +
       

     

       173
       173
       +
             for (const mutation of mutations) {

     

       174
       174
       +
               if (mutation.addedNodes.length) {

     

       175
       175
       +
                 hasNewInputs = true;

     

       176
       176
       +
       

     

       177
       177
       +
                 // Check if any new save buttons were added

     

       178
       178
       +
                 for (const node of mutation.addedNodes) {

     

       179
       179
       +
                   if (node.nodeType === 1) {

     

       180
       180
       +
                     // Node.ELEMENT_NODE is 1

     

       181
       181
       +
                     const newButtons = node.querySelectorAll

     

       182
       182
       +
                       ? node.querySelectorAll('[data-js-url-editor="save-create"]')

     

       183
       183
       +
                       : [];

     

       184
       184
       +
                     if (newButtons.length > 0) hasNewButtons = true;

     

       185
       185
       +
                   }

     

       186
       186
       +
                 }

     

       187
       187
       +
               }

     

       188
       188
       +
             }

     

       189
       189
       +
       

     

       190
       190
       +
             if (hasNewInputs) {

     

       191
       191
       +
               watchForHTTPEntries();

     

       192
       192
       +
             }

     

       193
       193
       +
       

     

       194
       194
       +
             if (hasNewButtons) {

     

       195
       195
       +
               // Observe any new buttons

     

       196
       196
       +
               const newSaveButtons = document.querySelectorAll(

     

       197
       197
       +
                 '[data-js-url-editor="save-create"]',

     

       198
       198
       +
               );

     

       199
       199
       +
               for (const button of newSaveButtons) {

     

       200
       200
       +
                 if (!button.hasAttributeObserver) {

     

       201
       201
       +
                   buttonObserver.observe(button, { attributes: true });

     

       202
       202
       +
                   button.hasAttributeObserver = true;

     

       203
       203
       +
                 }

     

       204
       204
       +
               }

     

       205
       205
       +
             }

     

       206
       206
       +
       

     

       207
       207
       +
             fixHttpButtons();

     

       208
       208
       +
             inputObserver.isProcessing = false;

     

       209
       209
       +
           }, 200);

     

       210
       210
       +
         });

     

       211
       211
       +
       

     

       212
       212
       +
         // Start observing the document with fewer things to watch

     

       213
       213
       +
         inputObserver.observe(document.body, {

     

       214
       214
       +
           childList: true,

     

       215
       215
       +
           subtree: true,

     

       216
       216
       +
         });

     

       217
       217
       +
       })();

+282

som-shortcuts.user.js

···

       1
       1
       +
       // ==UserScript==

     

       2
       2
       +
       // @name         Hack Club Summer Votes Helper

     

       3
       3
       +
       // @namespace    http://tampermonkey.net/

     

       4
       4
       +
       // @version      0.2

     

       5
       5
       +
       // @description  Enhance the voting experience on Hack Club Summer votes page

     

       6
       6
       +
       // @author       You

     

       7
       7
       +
       // @match        https://summer.hackclub.com/votes/new

     

       8
       8
       +
       // @match        https://summer.hackclub.com/votes/*

     

       9
       9
       +
       // @grant        none

     

       10
       10
       +
       // ==/UserScript==

     

       11
       11
       +
       

     

       12
       12
       +
       (() => {

     

       13
       13
       +
         console.log("Hack Club Summer Votes Helper loaded");

     

       14
       14
       +
       

     

       15
       15
       +
         function addHackClubSummerVotesHelperButton() {

     

       16
       16
       +
           // Prevent adding multiple buttons

     

       17
       17
       +
           if (document.getElementById("hackclub-summer-votes-helper-btn")) {

     

       18
       18
       +
             console.log("Button already exists, skipping");

     

       19
       19
       +
             return;

     

       20
       20
       +
           }

     

       21
       21
       +
       

     

       22
       22
       +
           // Find the <p class="text-center"> element

     

       23
       23
       +
           const p = document.querySelector("p.text-center");

     

       24
       24
       +
           if (!p) {

     

       25
       25
       +
             console.log("Target element not found yet");

     

       26
       26
       +
             return;

     

       27
       27
       +
           }

     

       28
       28
       +
       

     

       29
       29
       +
           console.log("Adding helper button");

     

       30
       30
       +
       

     

       31
       31
       +
           // Create a new button

     

       32
       32
       +
           const openButton = document.createElement("button");

     

       33
       33
       +
           openButton.textContent = "Open Project Links";

     

       34
       34
       +
           openButton.style.margin = "10px";

     

       35
       35
       +
           openButton.style.display = "block";

     

       36
       36
       +
           openButton.style.marginLeft = "auto";

     

       37
       37
       +
           openButton.style.marginRight = "auto";

     

       38
       38
       +
           openButton.className = "som-button-primary";

     

       39
       39
       +
           openButton.id = "hackclub-summer-votes-helper-btn";

     

       40
       40
       +
       

     

       41
       41
       +
           // Add click event to open the URLs

     

       42
       42
       +
           function openProjectLinks() {

     

       43
       43
       +
             console.log("Helper button clicked");

     

       44
       44
       +
       

     

       45
       45
       +
             // Find all buttons with a div > span whose text is "Demo" or "Repository"

     

       46
       46
       +
             const allButtons = Array.from(

     

       47
       47
       +
               document.getElementsByClassName("som-button-primary"),

     

       48
       48
       +
             );

     

       49
       49
       +
             const filteredButtons = allButtons.filter((btn) => {

     

       50
       50
       +
               const spans = btn.querySelectorAll("div > span");

     

       51
       51
       +
               return Array.from(spans).some((span) => {

     

       52
       52
       +
                 const text = span.textContent.trim();

     

       53
       53
       +
                 return text === "Demo" || text === "Repository";

     

       54
       54
       +
               });

     

       55
       55
       +
             });

     

       56
       56
       +
       

     

       57
       57
       +
             console.log(`Found ${filteredButtons.length} project buttons`);

     

       58
       58
       +
       

     

       59
       59
       +
             filteredButtons.forEach((btn) => {

     

       60
       60
       +
               const url = btn.href || btn.getAttribute("data-href");

     

       61
       61
       +
               if (url) {

     

       62
       62
       +
                 console.log(`Opening: ${url}`);

     

       63
       63
       +
                 window.open(url, "_blank");

     

       64
       64
       +
               }

     

       65
       65
       +
             });

     

       66
       66
       +
       

     

       67
       67
       +
             // Set the hidden inputs to true

     

       68
       68
       +
             const inputIds = [

     

       69
       69
       +
               "vote_project_1_demo_opened",

     

       70
       70
       +
               "vote_project_1_repo_opened",

     

       71
       71
       +
               "vote_project_2_demo_opened",

     

       72
       72
       +
               "vote_project_2_repo_opened",

     

       73
       73
       +
             ];

     

       74
       74
       +
       

     

       75
       75
       +
             inputIds.forEach((id) => {

     

       76
       76
       +
               const input = document.getElementById(id);

     

       77
       77
       +
               if (input) {

     

       78
       78
       +
                 input.value = "true";

     

       79
       79
       +
                 console.log(`Set ${id} to true`);

     

       80
       80
       +
               }

     

       81
       81
       +
             });

     

       82
       82
       +
           }

     

       83
       83
       +
       

     

       84
       84
       +
           openButton.addEventListener("click", openProjectLinks);

     

       85
       85
       +
       

     

       86
       86
       +
           p.appendChild(openButton);

     

       87
       87
       +
           console.log("Button added successfully");

     

       88
       88
       +
         }

     

       89
       89
       +
       

     

       90
       90
       +
         function runHelperOnPageLoad() {

     

       91
       91
       +
           // Only run on the correct page

     

       92
       92
       +
           if (

     

       93
       93
       +
             window.location.pathname === "/votes/new" ||

     

       94
       94
       +
             window.location.pathname.startsWith("/votes/")

     

       95
       95
       +
           ) {

     

       96
       96
       +
             console.log("Running helper on correct page");

     

       97
       97
       +
             addHackClubSummerVotesHelperButton();

     

       98
       98
       +
           }

     

       99
       99
       +
         }

     

       100
       100
       +
       

     

       101
       101
       +
         // Initial run

     

       102
       102
       +
         runHelperOnPageLoad();

     

       103
       103
       +
       

     

       104
       104
       +
         // Method 1: Intercept fetch/XMLHttpRequest to detect page changes

     

       105
       105
       +
         const originalFetch = window.fetch;

     

       106
       106
       +
         window.fetch = function (...args) {

     

       107
       107
       +
           return originalFetch.apply(this, args).then((response) => {

     

       108
       108
       +
             if (response.url.includes("/votes/new")) {

     

       109
       109
       +
               console.log("Detected fetch to votes page");

     

       110
       110
       +
               setTimeout(runHelperOnPageLoad, 100);

     

       111
       111
       +
             }

     

       112
       112
       +
             return response;

     

       113
       113
       +
           });

     

       114
       114
       +
         };

     

       115
       115
       +
       

     

       116
       116
       +
         const originalXHROpen = XMLHttpRequest.prototype.open;

     

       117
       117
       +
         XMLHttpRequest.prototype.open = function (method, url, ...rest) {

     

       118
       118
       +
           this.addEventListener("load", () => {

     

       119
       119
       +
             if (url.includes("/votes/new")) {

     

       120
       120
       +
               console.log("Detected XHR to votes page");

     

       121
       121
       +
               setTimeout(runHelperOnPageLoad, 100);

     

       122
       122
       +
             }

     

       123
       123
       +
           });

     

       124
       124
       +
           return originalXHROpen.call(this, method, url, ...rest);

     

       125
       125
       +
         };

     

       126
       126
       +
       

     

       127
       127
       +
         // Method 2: Enhanced MutationObserver

     

       128
       128
       +
         let observerTimeout;

     

       129
       129
       +
         const observer = new MutationObserver((_mutations) => {

     

       130
       130
       +
           // Debounce to avoid excessive calls

     

       131
       131
       +
           clearTimeout(observerTimeout);

     

       132
       132
       +
           observerTimeout = setTimeout(() => {

     

       133
       133
       +
             console.log("DOM mutation detected");

     

       134
       134
       +
             runHelperOnPageLoad();

     

       135
       135
       +
           }, 50);

     

       136
       136
       +
         });

     

       137
       137
       +
       

     

       138
       138
       +
         // Observe the entire document for changes

     

       139
       139
       +
         observer.observe(document.documentElement, {

     

       140
       140
       +
           childList: true,

     

       141
       141
       +
           subtree: true,

     

       142
       142
       +
           attributes: false,

     

       143
       143
       +
         });

     

       144
       144
       +
       

     

       145
       145
       +
         // Method 3: Polling fallback (less elegant but very reliable)

     

       146
       146
       +
         setInterval(() => {

     

       147
       147
       +
           if (

     

       148
       148
       +
             window.location.pathname === "/votes/new" ||

     

       149
       149
       +
             window.location.pathname.startsWith("/votes/")

     

       150
       150
       +
           ) {

     

       151
       151
       +
             if (!document.getElementById("hackclub-summer-votes-helper-btn")) {

     

       152
       152
       +
               console.log("Button missing, re-adding via polling");

     

       153
       153
       +
               addHackClubSummerVotesHelperButton();

     

       154
       154
       +
             }

     

       155
       155
       +
           }

     

       156
       156
       +
         }, 2000);

     

       157
       157
       +
       

     

       158
       158
       +
         // Method 4: Listen for history changes

     

       159
       159
       +
         const originalPushState = history.pushState;

     

       160
       160
       +
         const originalReplaceState = history.replaceState;

     

       161
       161
       +
       

     

       162
       162
       +
         history.pushState = function (...args) {

     

       163
       163
       +
           originalPushState.apply(this, args);

     

       164
       164
       +
           setTimeout(runHelperOnPageLoad, 100);

     

       165
       165
       +
         };

     

       166
       166
       +
       

     

       167
       167
       +
         history.replaceState = function (...args) {

     

       168
       168
       +
           originalReplaceState.apply(this, args);

     

       169
       169
       +
           setTimeout(runHelperOnPageLoad, 100);

     

       170
       170
       +
         };

     

       171
       171
       +
       

     

       172
       172
       +
         window.addEventListener("popstate", () => {

     

       173
       173
       +
           setTimeout(runHelperOnPageLoad, 100);

     

       174
       174
       +
         });

     

       175
       175
       +
       

     

       176
       176
       +
         // Method 5: Listen for focus events (when user returns to tab)

     

       177
       177
       +
         window.addEventListener("focus", () => {

     

       178
       178
       +
           setTimeout(runHelperOnPageLoad, 100);

     

       179
       179
       +
         });

     

       180
       180
       +
       

     

       181
       181
       +
         // Add listener for Shift + S shortcut

     

       182
       182
       +
         window.addEventListener("keydown", (e) => {

     

       183
       183
       +
           // Ignore if input/textarea/select is focused

     

       184
       184
       +
           const tag = document.activeElement.tagName;

     

       185
       185
       +
           if (

     

       186
       186
       +
             tag === "INPUT" ||

     

       187
       187
       +
             tag === "TEXTAREA" ||

     

       188
       188
       +
             tag === "SELECT" ||

     

       189
       189
       +
             document.activeElement.isContentEditable

     

       190
       190
       +
           ) {

     

       191
       191
       +
             return;

     

       192
       192
       +
           }

     

       193
       193
       +
           if (e.shiftKey && (e.key === "s" || e.key === "S")) {

     

       194
       194
       +
             // Only run on the correct page

     

       195
       195
       +
             if (

     

       196
       196
       +
               window.location.pathname === "/votes/new" ||

     

       197
       197
       +
               window.location.pathname.startsWith("/votes/")

     

       198
       198
       +
             ) {

     

       199
       199
       +
               const btn = document.getElementById("hackclub-summer-votes-helper-btn");

     

       200
       200
       +
               if (btn) {

     

       201
       201
       +
                 btn.click();

     

       202
       202
       +
               } else {

     

       203
       203
       +
                 // If button not present, run the logic directly

     

       204
       204
       +
                 // (duplicate logic from openButton click)

     

       205
       205
       +
                 // Find all buttons with a div > span whose text is "Demo" or "Repository"

     

       206
       206
       +
                 const allButtons = Array.from(

     

       207
       207
       +
                   document.getElementsByClassName("som-button-primary"),

     

       208
       208
       +
                 );

     

       209
       209
       +
                 const filteredButtons = allButtons.filter((btn) => {

     

       210
       210
       +
                   const spans = btn.querySelectorAll("div > span");

     

       211
       211
       +
                   return Array.from(spans).some((span) => {

     

       212
       212
       +
                     const text = span.textContent.trim();

     

       213
       213
       +
                     return text === "Demo" || text === "Repository";

     

       214
       214
       +
                   });

     

       215
       215
       +
                 });

     

       216
       216
       +
       

     

       217
       217
       +
                 filteredButtons.forEach((btn) => {

     

       218
       218
       +
                   const url = btn.href || btn.getAttribute("data-href");

     

       219
       219
       +
                   if (url) {

     

       220
       220
       +
                     window.open(url, "_blank");

     

       221
       221
       +
                   }

     

       222
       222
       +
                 });

     

       223
       223
       +
       

     

       224
       224
       +
                 // Set the hidden inputs to true

     

       225
       225
       +
                 const inputIds = [

     

       226
       226
       +
                   "vote_project_1_demo_opened",

     

       227
       227
       +
                   "vote_project_1_repo_opened",

     

       228
       228
       +
                   "vote_project_2_demo_opened",

     

       229
       229
       +
                   "vote_project_2_repo_opened",

     

       230
       230
       +
                 ];

     

       231
       231
       +
       

     

       232
       232
       +
                 inputIds.forEach((id) => {

     

       233
       233
       +
                   const input = document.getElementById(id);

     

       234
       234
       +
                   if (input) {

     

       235
       235
       +
                     input.value = "true";

     

       236
       236
       +
                   }

     

       237
       237
       +
                 });

     

       238
       238
       +
               }

     

       239
       239
       +
               // Prevent default browser behavior

     

       240
       240
       +
               e.preventDefault();

     

       241
       241
       +
             }

     

       242
       242
       +
           }

     

       243
       243
       +
         });

     

       244
       244
       +
       

     

       245
       245
       +
         // Add listener for Ctrl+Enter to submit vote, even in a textbox

     

       246
       246
       +
         window.addEventListener("keydown", (e) => {

     

       247
       247
       +
           if (e.ctrlKey && (e.key === "Enter" || e.keyCode === 13)) {

     

       248
       248
       +
             // Only run on the correct page

     

       249
       249
       +
             if (

     

       250
       250
       +
               window.location.pathname === "/votes/new" ||

     

       251
       251
       +
               window.location.pathname.startsWith("/votes/")

     

       252
       252
       +
             ) {

     

       253
       253
       +
               // Find the submit vote button

     

       254
       254
       +
               // <button name="button" type="submit" class="som-button-primary  " data-form-target="submitButton">

     

       255
       255
       +
               //     <div class="flex items-center justify-center gap-2">

     

       256
       256
       +
               //         <span class="flex items-center gap-1">Submit Vote</span>

     

       257
       257
       +
               //     </div>

     

       258
       258
       +
               // </button>

     

       259
       259
       +
               const submitButtons = Array.from(

     

       260
       260
       +
                 document.querySelectorAll(

     

       261
       261
       +
                   'button.som-button-primary[data-form-target="submitButton"]',

     

       262
       262
       +
                 ),

     

       263
       263
       +
               );

     

       264
       264
       +
               let found = false;

     

       265
       265
       +
               for (const btn of submitButtons) {

     

       266
       266
       +
                 // Check if the button contains a span with text "Submit Vote"

     

       267
       267
       +
                 const span = btn.querySelector("span");

     

       268
       268
       +
                 if (span && span.textContent.trim() === "Submit Vote") {

     

       269
       269
       +
                   btn.click();

     

       270
       270
       +
                   found = true;

     

       271
       271
       +
                   break;

     

       272
       272
       +
                 }

     

       273
       273
       +
               }

     

       274
       274
       +
               if (found) {

     

       275
       275
       +
                 e.preventDefault();

     

       276
       276
       +
               }

     

       277
       277
       +
             }

     

       278
       278
       +
           }

     

       279
       279
       +
         });

     

       280
       280
       +
       

     

       281
       281
       +
         console.log("All event listeners and observers set up");

     

       282
       282
       +
       })();

Compare changes