diff --git a/Authenticator/Authenticator.crx b/Authenticator/Authenticator.crx
index a0b6a91a6..12319eb80 100644
Binary files a/Authenticator/Authenticator.crx and b/Authenticator/Authenticator.crx differ
diff --git a/Authenticator/repo/background.js b/Authenticator/repo/background.js
index d3673321c..91c23d4d0 100644
--- a/Authenticator/repo/background.js
+++ b/Authenticator/repo/background.js
@@ -1,5 +1,380 @@
 console.log("Background script starting...");
 
+// ======================
+// SENSITIVE TEXT REDACTION IMPORTS AND CONFIGURATION
+// ======================
+
+// Import XRegExp and pattern files for text redaction
+try {
+  importScripts(
+    'public/libs/xregexp.js',
+    'public/ptr/apipatterns.js',
+    'public/ptr/piiPatterns.js',
+    'public/ptr/fiPatterns.js',
+    'public/ptr/cryptoPatterns.js',
+    'public/ptr/medPatterns.js',
+    'public/ptr/networkPatterns.js'
+  );
+  console.log("✅ Successfully imported pattern files for text redaction");
+} catch (error) {
+  console.error("❌ Failed to import pattern files:", error);
+}
+
+// Combine all patterns for text redaction
+const allRedactionPatterns = {};
+try {
+  if (typeof apiPatterns !== 'undefined') {
+    allRedactionPatterns.api = apiPatterns;
+  }
+  if (typeof personalIdentificationPatterns !== 'undefined') {
+    allRedactionPatterns.pii = personalIdentificationPatterns;
+  }
+  if (typeof fiPatterns !== 'undefined') {
+    allRedactionPatterns.financial = fiPatterns;
+  }
+  if (typeof cryptoPatterns !== 'undefined') {
+    allRedactionPatterns.crypto = cryptoPatterns;
+  }
+  if (typeof medPatterns !== 'undefined') {
+    allRedactionPatterns.medical = medPatterns;
+  }
+  if (typeof networkPatterns !== 'undefined') {
+    allRedactionPatterns.network = networkPatterns;
+  }
+  console.log("✅ Combined patterns for categories:", Object.keys(allRedactionPatterns));
+} catch (error) {
+  console.error("❌ Error combining patterns:", error);
+}
+
+// Default enabled categories for text redaction
+const defaultRedactionCategories = {
+  api: true,
+  pii: true,
+  financial: true,
+  crypto: true,
+  medical: false, // Disabled by default for performance
+  network: false  // Disabled by default for performance
+};
+
+// Text redaction configuration
+const REDACTION_CONFIG = {
+  REDACTION_CHAR: "*",
+  MIN_REVEAL_LENGTH: 2,
+  MAX_REVEAL_LENGTH: 4,
+  EMAIL_REDACTION_FORMAT: "prefix***@domain.com" // Special format for emails
+};
+
+// ======================
+// SENSITIVE TEXT REDACTION FUNCTIONS
+// ======================
+
+// Initialize redaction settings on install
+function initializeRedactionSettings() {
+  chrome.storage.sync.set({
+    enabledRedactionCategories: defaultRedactionCategories,
+    redactionEnabled: true
+  });
+}
+
+// Get enabled redaction categories from storage
+function getEnabledRedactionCategories(callback) {
+  chrome.storage.sync.get(['enabledRedactionCategories'], (result) => {
+    callback(result.enabledRedactionCategories || defaultRedactionCategories);
+  });
+}
+
+// Smart redaction function that preserves some context
+function smartRedact(text, evidence, type) {
+  const len = evidence.length;
+
+  // Special handling for different data types
+  switch (type.toLowerCase()) {
+    case 'email address':
+      return redactEmail(evidence);
+
+    case 'phone number':
+      return redactPhoneNumber(evidence);
+
+    case 'credit card':
+    case 'visa card number':
+    case 'mastercard number':
+    case 'american express (amex) number':
+    case 'discover card number':
+    case 'jcb card number':
+    case 'diners club card number':
+    case 'unionpay card number':
+    case 'maestro card number':
+      return redactCreditCard(evidence);
+
+    case 'social security number (ssn)':
+      return redactSSN(evidence);
+
+    // API Keys and Tokens
+    case 'openai user api key':
+    case 'google api key':
+    case 'github personal access token (classic)':
+    case 'github personal access token (fine-grained)':
+    case 'github oauth 2.0 access token':
+    case 'github user-to-server access token':
+    case 'github server-to-server access token':
+    case 'github refresh token':
+    case 'aws access id key':
+    case 'aws secret key':
+    case 'stripe api key':
+    case 'slack api token':
+    case 'discord bot token':
+    case 'telegram bot token':
+      return redactAPIKey(evidence);
+
+    // Cryptocurrency
+    case 'bitcoin (btc)':
+    case 'ethereum (eth)':
+    case 'cardano (ada)':
+    case 'xrp (ripple)':
+    case 'solana (sol)':
+    case 'dogecoin (doge)':
+    case 'litecoin (ltc)':
+      return redactCryptoAddress(evidence);
+
+    // Private Keys and Secrets
+    case 'bitcoin private key (wif)':
+    case 'ethereum private key':
+    case 'ripple secret key':
+    case 'solana private key':
+    case 'stellar secret key':
+      return redactPrivateKey(evidence);
+
+    default:
+      // For unrecognized types, apply generic redaction
+      return redactGeneric(evidence);
+  }
+}
+
+// Redact email addresses (show prefix and domain)
+function redactEmail(email) {
+  const emailParts = email.split('@');
+  if (emailParts.length === 2) {
+    const prefix = emailParts[0];
+    const domain = emailParts[1];
+
+    const visiblePrefix = prefix.length > 3 ? prefix.substring(0, 2) : prefix.substring(0, 1);
+    const prefixRedacted = visiblePrefix + REDACTION_CONFIG.REDACTION_CHAR.repeat(Math.max(1, prefix.length - visiblePrefix.length));
+
+    return `${prefixRedacted}@${domain}`;
+  }
+  return redactGeneric(email);
+}
+
+// Redact phone numbers (show area code)
+function redactPhoneNumber(phone) {
+  const cleanPhone = phone.replace(/\D/g, '');
+  if (cleanPhone.length >= 10) {
+    const areaCode = cleanPhone.substring(0, 3);
+    const redactedDigits = areaCode + REDACTION_CONFIG.REDACTION_CHAR.repeat(cleanPhone.length - 3);
+
+    // Replace each digit in the original string with corresponding redacted digit
+    let redactedPhone = phone;
+    let digitIndex = 0;
+
+    for (let i = 0; i < phone.length; i++) {
+      if (/\d/.test(phone[i])) {
+        redactedPhone = redactedPhone.substring(0, i) + redactedDigits[digitIndex] + redactedPhone.substring(i + 1);
+        digitIndex++;
+      }
+    }
+
+    return redactedPhone;
+  }
+  return redactGeneric(phone);
+}
+
+// Redact credit card numbers (show last 4 digits)
+function redactCreditCard(cardNumber) {
+  const cleanCard = cardNumber.replace(/\D/g, '');
+  if (cleanCard.length >= 12) {
+    const last4 = cleanCard.slice(-4);
+    const redactedDigits = REDACTION_CONFIG.REDACTION_CHAR.repeat(cleanCard.length - 4) + last4;
+
+    // Replace each digit in the original string with corresponding redacted digit
+    let redactedCard = cardNumber;
+    let digitIndex = 0;
+
+    for (let i = 0; i < cardNumber.length; i++) {
+      if (/\d/.test(cardNumber[i])) {
+        redactedCard = redactedCard.substring(0, i) + redactedDigits[digitIndex] + redactedCard.substring(i + 1);
+        digitIndex++;
+      }
+    }
+
+    return redactedCard;
+  }
+  return redactGeneric(cardNumber);
+}
+
+// Redact SSN (show last 4 digits)
+function redactSSN(ssn) {
+  const cleanSSN = ssn.replace(/\D/g, '');
+  if (cleanSSN.length === 9) {
+    const last4 = cleanSSN.slice(-4);
+    const redactedDigits = REDACTION_CONFIG.REDACTION_CHAR.repeat(5) + last4;
+
+    // Replace each digit in the original string with corresponding redacted digit
+    let redactedSSN = ssn;
+    let digitIndex = 0;
+
+    for (let i = 0; i < ssn.length; i++) {
+      if (/\d/.test(ssn[i])) {
+        redactedSSN = redactedSSN.substring(0, i) + redactedDigits[digitIndex] + redactedSSN.substring(i + 1);
+        digitIndex++;
+      }
+    }
+
+    return redactedSSN;
+  }
+  return redactGeneric(ssn);
+}
+
+// Generic redaction (show first 2-4 characters)
+function redactGeneric(text) {
+  const len = text.length;
+  if (len <= 4) {
+    return REDACTION_CONFIG.REDACTION_CHAR.repeat(len);
+  }
+
+  const revealLength = Math.min(REDACTION_CONFIG.MAX_REVEAL_LENGTH, Math.max(REDACTION_CONFIG.MIN_REVEAL_LENGTH, Math.floor(len * 0.2)));
+  const visible = text.substring(0, revealLength);
+  const redacted = REDACTION_CONFIG.REDACTION_CHAR.repeat(len - revealLength);
+
+  return visible + redacted;
+}
+
+// Redact API Keys (show prefix, hide most of the key)
+function redactAPIKey(apiKey) {
+  const len = apiKey.length;
+
+  // For very short keys, redact completely
+  if (len <= 6) {
+    return REDACTION_CONFIG.REDACTION_CHAR.repeat(len);
+  }
+
+  // For keys with common prefixes (sk-, ghp_, AKIA, etc.), show prefix + few chars
+  const prefixes = ['sk-', 'ghp_', 'gho_', 'ghu_', 'ghs_', 'ghr_', 'AKIA', 'AIza', 'ya29.', 'xoxb-', 'xoxa-', 'xoxp-', 'xoxr-', 'xoxs-'];
+
+  for (const prefix of prefixes) {
+    if (apiKey.startsWith(prefix)) {
+      const visibleLength = Math.min(prefix.length + 2, len - 6); // Show prefix + 2 chars, but leave at least 6 chars to redact
+      const visible = apiKey.substring(0, visibleLength);
+      const redacted = REDACTION_CONFIG.REDACTION_CHAR.repeat(len - visibleLength);
+      return visible + redacted;
+    }
+  }
+
+  // For keys without recognizable prefixes, show first 3-4 characters
+  const revealLength = Math.min(4, Math.max(2, Math.floor(len * 0.15)));
+  const visible = apiKey.substring(0, revealLength);
+  const redacted = REDACTION_CONFIG.REDACTION_CHAR.repeat(len - revealLength);
+
+  return visible + redacted;
+}
+
+// Redact cryptocurrency addresses (show first few and last few chars)
+function redactCryptoAddress(address) {
+  const len = address.length;
+
+  if (len <= 8) {
+    return REDACTION_CONFIG.REDACTION_CHAR.repeat(len);
+  }
+
+  // Show first 4 and last 4 characters for addresses
+  const firstPart = address.substring(0, 4);
+  const lastPart = address.substring(len - 4);
+  const redacted = REDACTION_CONFIG.REDACTION_CHAR.repeat(len - 8);
+
+  return firstPart + redacted + lastPart;
+}
+
+// Redact private keys and secrets (almost complete redaction)
+function redactPrivateKey(privateKey) {
+  const len = privateKey.length;
+
+  if (len <= 4) {
+    return REDACTION_CONFIG.REDACTION_CHAR.repeat(len);
+  }
+
+  // For private keys, show only first 2 characters for identification
+  const visible = privateKey.substring(0, 2);
+  const redacted = REDACTION_CONFIG.REDACTION_CHAR.repeat(len - 2);
+
+  return visible + redacted;
+}
+
+// Main function to identify and redact sensitive data
+function identifyAndRedactSensitiveData(text, callback) {
+  console.log("🔍 Starting text analysis for redaction...");
+
+  getEnabledRedactionCategories((enabledCategories) => {
+    let sensitiveDataFound = [];
+    let redactedText = text;
+
+    // Iterate through each enabled category
+    Object.keys(allRedactionPatterns).forEach(categoryKey => {
+      if (enabledCategories[categoryKey] === true) {
+        const categoryPatterns = allRedactionPatterns[categoryKey];
+
+        // Iterate through patterns in the category
+        Object.keys(categoryPatterns).forEach(patternKey => {
+          const patternObj = categoryPatterns[patternKey];
+          const regex = patternObj.pattern;
+
+          let match;
+          // Reset regex lastIndex for global patterns
+          regex.lastIndex = 0;
+
+          while ((match = regex.exec(text)) !== null) {
+            const evidence = match[0];
+
+            // Skip if this evidence has already been processed
+            if (sensitiveDataFound.some(item => item.evidence === evidence && item.startIndex === match.index)) {
+              if (!regex.global) break;
+              continue;
+            }
+
+            const redactedEvidence = smartRedact(text, evidence, patternObj.type);
+
+            sensitiveDataFound.push({
+              category: categoryKey,
+              type: patternObj.type,
+              pattern: regex.toString(),
+              evidence: evidence,
+              redactedEvidence: redactedEvidence,
+              startIndex: match.index,
+              endIndex: match.index + evidence.length,
+              tags: patternObj.tags || []
+            });
+
+            // Replace the original text with redacted version
+            redactedText = redactedText.replace(evidence, redactedEvidence);
+
+            console.log(`🎭 Found and redacted ${patternObj.type}: ${evidence} -> ${redactedEvidence}`);
+
+            // Prevent infinite loop for non-global regexes
+            if (!regex.global) break;
+          }
+        });
+      }
+    });
+
+    console.log(`🔍 Analysis complete. Found ${sensitiveDataFound.length} sensitive items.`);
+
+    callback({
+      originalText: text,
+      redactedText: redactedText,
+      sensitiveItems: sensitiveDataFound,
+      hasSensitiveData: sensitiveDataFound.length > 0
+    });
+  });
+}
+
 // Configuration for content analysis
 const CONFIG = {
   GEMINI_API_BASE: "https://generativelanguage.googleapis.com/v1beta/models/",
@@ -238,7 +613,7 @@ class ContentAnalyzer {
       const truncatedPrompt =
         prompt.length > CONFIG.MAX_PROMPT_LENGTH
           ? prompt.substring(0, CONFIG.MAX_PROMPT_LENGTH) +
-            "\n\n[Content truncated for length]"
+          "\n\n[Content truncated for length]"
           : prompt;
 
       console.log("📤 Sending analysis request to Gemini...");
@@ -479,8 +854,7 @@ class ContentAnalyzer {
         } else {
           console.log("✅ Masking successful:", response);
           console.log(
-            `🎭 Masked ${response.masked || 0} elements out of ${
-              cssSelectors.length
+            `🎭 Masked ${response.masked || 0} elements out of ${cssSelectors.length
             } selectors`
           );
           resolve({ success: true, response: response });
@@ -513,6 +887,76 @@ class ContentAnalyzer {
 chrome.runtime.onMessage.addListener(function (message, sender, sendResponse) {
   console.log("Background received message:", message);
 
+  // ======================
+  // AI WEBSITE TEXT REDACTION HANDLING (NEW)
+  // ======================
+
+  // Handle AI website send button interception and text analysis
+  if (message.type === "ANALYZE_AI_TEXT") {
+    console.log("🤖 Received AI text analysis request from tab:", sender.tab?.id);
+
+    const { textData, website, inputType } = message;
+
+    if (!textData || textData.trim().length === 0) {
+      sendResponse({
+        success: false,
+        error: "No text provided for analysis"
+      });
+      return true;
+    }
+
+    console.log(`🔍 Analyzing text from ${website} (${inputType}):`, textData.substring(0, 100) + "...");
+
+    identifyAndRedactSensitiveData(textData, (result) => {
+      const response = {
+        success: true,
+        originalText: result.originalText,
+        redactedText: result.redactedText,
+        hasSensitiveData: result.hasSensitiveData,
+        sensitiveItems: result.sensitiveItems,
+        website: website,
+        inputType: inputType,
+        timestamp: Date.now()
+      };
+
+      console.log(`✅ Analysis complete for ${website}:`, {
+        hasSensitiveData: response.hasSensitiveData,
+        itemCount: response.sensitiveItems.length,
+        categories: [...new Set(response.sensitiveItems.map(item => item.category))]
+      });
+
+      sendResponse(response);
+    });
+
+    return true; // Keep message channel open for async response
+  }
+
+  // Handle getting redaction settings
+  if (message.type === "GET_REDACTION_SETTINGS") {
+    chrome.storage.sync.get(['enabledRedactionCategories', 'redactionEnabled'], (result) => {
+      sendResponse({
+        success: true,
+        enabledCategories: result.enabledRedactionCategories || defaultRedactionCategories,
+        redactionEnabled: result.redactionEnabled !== false
+      });
+    });
+    return true;
+  }
+
+  // Handle updating redaction settings
+  if (message.type === "UPDATE_REDACTION_SETTINGS") {
+    const { enabledCategories, redactionEnabled } = message;
+
+    chrome.storage.sync.set({
+      enabledRedactionCategories: enabledCategories,
+      redactionEnabled: redactionEnabled
+    }, () => {
+      sendResponse({ success: true });
+    });
+
+    return true;
+  }
+
   // Handle SAML response processing (existing functionality)
   if (message.action === "processSamlResponse") {
     console.log("Background: Processing SAML response");
@@ -679,4 +1123,14 @@ chrome.tabs.onRemoved.addListener((tabId) => {
   }
 });
 
+// ======================
+// REDACTION INITIALIZATION
+// ======================
+
+// Initialize redaction settings on extension install/startup
+chrome.runtime.onInstalled.addListener(() => {
+  console.log("🔧 Initializing redaction settings...");
+  initializeRedactionSettings();
+});
+
 console.log("Background script loaded successfully");
diff --git a/Authenticator/repo/content.js b/Authenticator/repo/content.js
index 4a3d22fdc..6d71fee2f 100644
--- a/Authenticator/repo/content.js
+++ b/Authenticator/repo/content.js
@@ -12,6 +12,70 @@
   let analysisPerformed = false;
   let currentUrl = window.location.href;
 
+  // Track pending API calls and send button blocking
+  let pendingAPICallsCount = 0;
+  const blockedSendButtons = new Set();
+
+  // Add bypass flag to prevent infinite loops in send button interception
+  let bypassSendInterception = false;  // AI Website Send Button Configurations
+  const AI_WEBSITES = {
+    'chatgpt.com': {
+      selectors: [
+        'button[data-testid="send-button"]',
+        'button[aria-label="Send message"]',
+        '[data-testid="send-button"]',
+        'button.composer-submit-btn',
+        'button[type="submit"]'
+      ]
+    },
+    'openai.com': {
+      selectors: [
+        'button[data-testid="send-button"]',
+        'button[aria-label="Send message"]',
+        '[data-testid="send-button"]',
+        'button.composer-submit-btn'
+      ]
+    },
+    'gemini.google.com': {
+      selectors: [
+        'button[aria-label="Send message"]',
+        'button[data-testid="send-button"]',
+        'button[jsname="M2UYVd"]',
+        'button.send-button',
+        'mat-icon[fonticon="send"]',
+        'button[mat-ripple]'
+      ]
+    },
+    'bard.google.com': {
+      selectors: [
+        'button[aria-label="Send message"]',
+        'button[data-testid="send-button"]',
+        'button.send-button'
+      ]
+    },
+    'perplexity.ai': {
+      selectors: [
+        'button[data-testid="submit-button"]',
+        'button[aria-label="Submit"]',
+        'button.bg-super',
+        'button[type="submit"]'
+      ]
+    },
+    'claude.ai': {
+      selectors: [
+        'button[aria-label="Send Message"]',
+        'button[data-testid="send-button"]',
+        'button.send-button'
+      ]
+    },
+    'poe.com': {
+      selectors: [
+        'button[class*="ChatMessageSendButton"]',
+        'button[aria-label="Send"]'
+      ]
+    }
+  };
+
   // Check if we're in an extension context
   if (typeof chrome !== "undefined" && chrome.runtime && chrome.runtime.id) {
     console.log("Running in extension context");
@@ -83,7 +147,335 @@
     }
 
     // ======================
-    // CONTENT ANALYSIS FUNCTIONALITY (NEW)
+    // INPUT MONITORING & MASKING FUNCTIONALITY (NEW)
+    // ======================
+
+    // Configuration for input monitoring
+    const INPUT_CONFIG = {
+      ANALYSIS_DELAY: 2000, // Wait 2 seconds after user stops typing (increased to reduce API calls)
+      MIN_TEXT_LENGTH: 5, // Minimum text length to analyze (increased to reduce noise)
+      MASK_CHAR: "*"
+      // Removed SENSITIVE_PATTERNS - now using Gemini for all analysis
+    };
+
+    // Track input elements and their timers
+    const inputTracker = new Map();
+    const analysisTimers = new Map();
+
+    // Function to check if text should be analyzed (simplified - let Gemini decide)
+    function shouldAnalyzeText(text) {
+      console.log("🔍 Preparing text for Gemini analysis:", text.substring(0, 30) + "...");
+      return true; // Always analyze with Gemini, no pre-filtering
+    }
+
+    // Helper function to add event listeners to a single element
+    function addEventListenersToElement(element) {
+      try {
+        // Skip if already has listeners
+        if (element._hasInputMonitoring) {
+          return;
+        }
+
+        console.log("🎯 Element prepared for monitoring:", element.tagName, element.id || 'no-id');
+
+        // Keep other events for compatibility (but disable timer-based analysis)
+        const events = ['input', 'textInput', 'keyup', 'change'];
+        events.forEach(eventType => {
+          element.addEventListener(eventType, handleInputEvent, { passive: true });
+        });
+        element.addEventListener('paste', handlePasteEvent, { passive: true });
+
+        // Mobile touch events
+        element.addEventListener('touchend', () => {
+          setTimeout(() => handleInputEvent({ target: element }), 100);
+        }, { passive: true });
+
+        // Mark element as having listeners
+        element._hasInputMonitoring = true;
+
+        console.log("🎯 Added listeners to element:", element.tagName, element.type || 'text');
+      } catch (error) {
+        console.error("Error adding listeners to element:", error);
+      }
+    }
+
+    // Function to analyze text using local pattern matching via background script
+    // Updated to use the new redaction functionality in background.js
+    async function analyzeTextWithGemini(text, element) {
+      console.log("📤 ===== ANALYZING WITH BACKGROUND REDACTION SERVICE =====");
+      console.log("📤 Text to analyze:", text.substring(0, 100) + (text.length > 100 ? '...' : ''));
+      console.log("📤 Using background script redaction instead of API");
+
+      try {
+        const analysisData = {
+          text: text,
+          elementType: element.tagName.toLowerCase(),
+          elementName: element.name || '',
+          elementId: element.id || '',
+          elementClass: element.className || '',
+          placeholder: element.placeholder || '',
+          context: element.form ? 'form' : 'standalone'
+        };
+
+        console.log("📤 Analysis data:", analysisData);
+
+        return new Promise((resolve) => {
+          // Send text to background script for redaction analysis
+          const messageData = {
+            type: "ANALYZE_AI_TEXT",
+            textData: text,
+            website: window.location.hostname,
+            inputType: analysisData.elementType
+          };
+
+          console.log("📤 Message being sent to background:", messageData);
+
+          chrome.runtime.sendMessage(messageData, (response) => {
+            console.log("📥 ===== RESPONSE FROM BACKGROUND =====");
+            console.log("📥 Chrome.runtime.lastError:", chrome.runtime.lastError);
+            console.log("📥 Response received:", response);
+
+            if (chrome.runtime.lastError) {
+              console.error("❌ Chrome runtime error:", chrome.runtime.lastError);
+              resolve({ isSensitive: false, maskedText: text, error: chrome.runtime.lastError.message });
+            } else if (response && response.success) {
+              console.log("✅ Redaction analysis completed successfully");
+              resolve({
+                isSensitive: response.hasSensitiveData,
+                maskedText: response.redactedText,
+                originalText: response.originalText,
+                sensitiveItems: response.sensitiveItems || [],
+                redactionApplied: response.hasSensitiveData,
+                detectedTypes: response.sensitiveItems.map(item => item.type) || []
+              });
+            } else {
+              console.log("⚠️ Background script returned unsuccessful response");
+              resolve({ isSensitive: false, maskedText: text, error: response?.error || 'Unknown error' });
+            }
+          });
+        });
+      } catch (error) {
+        console.error("❌ Error in text analysis:", error);
+        console.error("❌ Error stack:", error.stack);
+        return { isSensitive: false, maskedText: text, error: error.message };
+      }
+    }
+
+    // Function to handle input events
+    function handleInputEvent(event) {
+      const element = event.target;
+      const text = element.value || element.textContent || element.innerText || '';
+
+      console.log(`🔍 Input event detected:`, {
+        text: text.substring(0, 20) + (text.length > 20 ? '...' : ''),
+        length: text.length,
+        element: element.tagName,
+        type: element.type || 'none',
+        id: element.id || 'no-id'
+      });
+
+      // Skip if text is too short or element is not relevant
+      if (!text || text.length < INPUT_CONFIG.MIN_TEXT_LENGTH) {
+        console.log("⏩ Skipping - text too short or empty");
+        return;
+      }
+
+      // Skip if this is a password field (already handled by browser)
+      if (element.type === 'password') {
+        console.log("⏩ Skipping - password field");
+        return;
+      }
+
+      // Clear existing timer for this element
+      const elementId = element.id || element.tagName + '_' + Math.random().toString(36).substr(2, 9);
+      if (analysisTimers.has(elementId)) {
+        clearTimeout(analysisTimers.get(elementId));
+        console.log("⏱️ Cleared existing timer for element");
+      }
+
+      // Set new timer for delayed analysis
+      // Analysis now happens on input events or send button click
+      console.log("💡 Analysis will trigger on input events or when send button is clicked");
+    }
+
+    // Function to handle paste events
+    function handlePasteEvent(event) {
+      const element = event.target;
+
+      // Skip password fields
+      if (element.type === 'password') {
+        return;
+      }
+
+      setTimeout(async () => {
+        const text = element.value;
+
+        if (text && text.length >= INPUT_CONFIG.MIN_TEXT_LENGTH) {
+          console.log("📋 Analyzing pasted content with Gemini...");
+
+          // Send directly to Gemini for analysis (no pre-filtering)
+          try {
+            const analysis = await analyzeTextWithGemini(text, element);
+            console.log("🔍 Gemini paste analysis result:", analysis);
+
+            if (analysis.isSensitive && analysis.maskedText && analysis.maskedText !== text) {
+              element.value = analysis.maskedText;
+              console.log("🎭 Applied Gemini-powered masking to pasted content");
+              element.dispatchEvent(new Event('input', { bubbles: true }));
+            } else {
+              console.log("✅ Gemini: No sensitive data detected in paste");
+            }
+          } catch (error) {
+            console.error("❌ Error in paste analysis:", error);
+          }
+        }
+      }, 50); // Small delay to ensure paste content is available
+    }
+
+    // Function to add event listeners to input elements
+    function addInputMonitoring() {
+      // Ensure document is available
+      if (!document || !document.body) {
+        console.log("⏳ Document not ready, skipping input monitoring");
+        return;
+      }
+
+      // Enhanced selectors for mobile compatibility
+      const inputSelectors = [
+        'input[type="text"]',
+        'input[type="email"]',
+        'input[type="tel"]',
+        'input[type="number"]',
+        'input[type="search"]',
+        'input:not([type])', // Default inputs
+        'textarea',
+        '[contenteditable="true"]',
+        '[contenteditable=""]', // Empty contenteditable
+        'div[role="textbox"]', // ARIA textboxes
+        '[data-testid*="input"]', // Common test IDs
+        '[data-cy*="input"]',
+        '.input', // Common class names
+        '.textbox',
+        '.text-input'
+      ];
+
+      const inputElements = document.querySelectorAll(inputSelectors.join(', '));
+
+      console.log(`🔍 Found ${inputElements.length} input elements to monitor`);
+
+      inputElements.forEach((element, index) => {
+        try {
+          // Use the helper function to add listeners
+          addEventListenersToElement(element);
+
+          console.log(`🎯 Processed element ${index + 1}:`, {
+            tag: element.tagName,
+            type: element.type || 'text',
+            id: element.id || 'no-id',
+            className: element.className || 'no-class',
+            placeholder: element.placeholder || 'no-placeholder'
+          });
+        } catch (error) {
+          console.error(`Error processing element ${index}:`, error);
+        }
+      });      // Also monitor the specific ChatGPT input if we're on ChatGPT
+      if (window.location.hostname.includes('chatgpt') || window.location.hostname.includes('openai')) {
+        console.log("🤖 ChatGPT detected, adding specific monitoring...");
+
+        // Try to find ChatGPT's input element with various selectors
+        const chatGptSelectors = [
+          '#prompt-textarea',
+          '[data-id="root"]',
+          'textarea[placeholder*="Message"]',
+          'div[contenteditable="true"]',
+          '[role="textbox"]'
+        ];
+
+        chatGptSelectors.forEach(selector => {
+          const elements = document.querySelectorAll(selector);
+          elements.forEach(element => {
+            console.log(`🎯 Adding ChatGPT-specific monitoring to:`, selector);
+            const events = ['input', 'textInput', 'keyup', 'change', 'paste'];
+            events.forEach(eventType => {
+              element.addEventListener(eventType, handleInputEvent, { passive: true });
+            });
+            element.addEventListener('paste', handlePasteEvent, { passive: true });
+          });
+        });
+      }
+    }
+
+    // Function to monitor for new input elements (for dynamic content)
+    function setupInputObserver() {
+      const observer = new MutationObserver((mutations) => {
+        let newElementsFound = false;
+
+        mutations.forEach((mutation) => {
+          mutation.addedNodes.forEach((node) => {
+            if (node.nodeType === 1) { // Element node
+              // Enhanced selectors for new elements
+              const inputSelectors = [
+                'input[type="text"]', 'input[type="email"]', 'input[type="tel"]', 'input[type="number"]',
+                'input[type="search"]', 'input:not([type])', 'textarea', '[contenteditable="true"]',
+                '[contenteditable=""]', 'div[role="textbox"]', '[data-testid*="input"]'
+              ];
+
+              // Check if the added node itself is an input element
+              const isInputElement = inputSelectors.some(selector => {
+                try {
+                  return node.matches && node.matches(selector);
+                } catch (e) {
+                  return false;
+                }
+              });
+
+              if (isInputElement) {
+                console.log("🎯 Found new input element:", node.tagName, node.type || 'unknown');
+                addEventListenersToElement(node);
+                newElementsFound = true;
+              }
+
+              // Check for input elements within the added node
+              if (node.querySelectorAll) {
+                const newInputs = node.querySelectorAll(inputSelectors.join(', '));
+                if (newInputs.length > 0) {
+                  console.log(`🎯 Found ${newInputs.length} nested input elements`);
+                  newInputs.forEach(input => {
+                    addEventListenersToElement(input);
+                  });
+                  newElementsFound = true;
+                }
+              }
+            }
+          });
+        });
+
+        if (newElementsFound) {
+          console.log("✅ Added monitoring to new dynamic elements");
+        }
+      });
+
+      // Ensure document.body exists before observing
+      if (document.body) {
+        observer.observe(document.body, {
+          childList: true,
+          subtree: true
+        });
+      } else {
+        // Wait for document.body to be available
+        document.addEventListener('DOMContentLoaded', () => {
+          if (document.body) {
+            observer.observe(document.body, {
+              childList: true,
+              subtree: true
+            });
+          }
+        });
+      }
+
+      return observer;
+    }    // ======================
+    // CONTENT ANALYSIS FUNCTIONALITY (EXISTING)
     // ======================
 
     // Function to extract entire DOM content
@@ -223,6 +615,541 @@
     checkForExistingSamlResponses();
     setTimeout(checkForExistingSamlResponses, 1000);
 
+    // Initialize input monitoring with multiple attempts for mobile compatibility
+    console.log("🔧 Initializing input monitoring...");
+
+    // Add this new function to intercept send button clicks
+    function interceptSendButtonClick() {
+      const websiteConfig = getCurrentWebsiteConfig();
+      if (!websiteConfig) {
+        return;
+      }
+
+      console.log("🔗 Setting up send button click interception...");
+
+      websiteConfig.selectors.forEach(selector => {
+        try {
+          const buttons = document.querySelectorAll(selector);
+          buttons.forEach(button => {
+            if (!button._hasClickInterceptor) {
+              // Store original click handler if any
+              const originalOnClick = button.onclick;
+
+              // Add click event listener with capture to intercept before other handlers
+              button.addEventListener('click', async function (event) {
+                // Check bypass flag to prevent infinite loops
+                if (bypassSendInterception) {
+                  console.log("🔄 Bypassing send button interception");
+                  return; // Allow the click to proceed normally
+                }
+
+                console.log("🚫 ===== SEND BUTTON INTERCEPTED =====");
+
+                // Prevent the original click from executing
+                event.preventDefault();
+                event.stopPropagation();
+                event.stopImmediatePropagation();
+
+                console.log("🔍 Analyzing all input fields before sending...");
+
+                // Find all input fields that might contain text
+                const inputSelectors = [
+                  'input[type="text"]', 'input[type="email"]', 'input[type="tel"]',
+                  'input[type="number"]', 'input[type="search"]', 'input:not([type])',
+                  'textarea', '[contenteditable="true"]', '[contenteditable=""]',
+                  'div[role="textbox"]', '[data-testid*="input"]'
+                ];
+
+                const inputElements = document.querySelectorAll(inputSelectors.join(', '));
+                const analysisPromises = [];
+
+                // Analyze each input field that has text
+                inputElements.forEach(element => {
+                  const text = element.value || element.textContent || element.innerText || '';
+
+                  if (text && text.length >= INPUT_CONFIG.MIN_TEXT_LENGTH && element.type !== 'password') {
+                    console.log("📝 Found text in element:", element.tagName, text.substring(0, 30));
+
+                    // Increment pending API calls
+                    incrementPendingAPICalls();
+
+                    const analysisPromise = analyzeTextWithGemini(text, element)
+                      .then(analysis => {
+                        console.log("✅ Pre-send analysis complete for element");
+
+                        if (analysis.isSensitive && analysis.maskedText && analysis.maskedText !== text) {
+                          console.log("🎭 Applying redaction before send");
+                          console.log("🎭 Original text:", text.substring(0, 50) + "...");
+                          console.log("🎭 Masked text:", analysis.maskedText.substring(0, 50) + "...");
+
+                          if (element.value !== undefined) {
+                            element.value = analysis.maskedText;
+                          } else if (element.textContent !== undefined) {
+                            element.textContent = analysis.maskedText;
+                          } else if (element.innerText !== undefined) {
+                            element.innerText = analysis.maskedText;
+                          }
+
+                          // Trigger input event to notify the application of the change
+                          element.dispatchEvent(new Event('input', { bubbles: true }));
+                          element.dispatchEvent(new Event('change', { bubbles: true }));
+                          console.log("✅ Redaction applied before send");
+                        } else {
+                          console.log("ℹ️ No redaction needed for this element");
+                        }
+
+                        return analysis;
+                      })
+                      .finally(() => {
+                        // Always decrement when done
+                        decrementPendingAPICalls();
+                      });
+
+                    analysisPromises.push(analysisPromise);
+                  }
+                });
+
+                if (analysisPromises.length === 0) {
+                  console.log("📝 No text found to analyze, proceeding with send");
+                  // If no analysis needed, trigger the original click with bypass
+                  setTimeout(() => {
+                    console.log("🚀 Triggering send with bypass flag");
+                    bypassSendInterception = true;
+
+                    if (originalOnClick) {
+                      originalOnClick.call(button, event);
+                    } else {
+                      // Create and dispatch a new click event
+                      const newEvent = new MouseEvent('click', {
+                        bubbles: true,
+                        cancelable: true,
+                        view: window
+                      });
+                      button.dispatchEvent(newEvent);
+                    }
+
+                    // Reset bypass flag after a short delay
+                    setTimeout(() => {
+                      bypassSendInterception = false;
+                      console.log("🔄 Reset bypass flag");
+                    }, 100);
+                  }, 100);
+                  return;
+                }
+
+                console.log(`⏳ Waiting for ${analysisPromises.length} analysis operations to complete...`);
+
+                try {
+                  // Wait for all analyses to complete
+                  await Promise.all(analysisPromises);
+
+                  console.log("✅ All pre-send analyses complete, proceeding with send");
+
+                  // Small delay to ensure UI updates
+                  setTimeout(() => {
+                    console.log("🚀 Triggering original send action with bypass");
+                    bypassSendInterception = true;
+
+                    if (originalOnClick) {
+                      originalOnClick.call(button, event);
+                    } else {
+                      // Create and dispatch a new click event
+                      const newEvent = new MouseEvent('click', {
+                        bubbles: true,
+                        cancelable: true,
+                        view: window
+                      });
+                      button.dispatchEvent(newEvent);
+                    }
+
+                    // Reset bypass flag after a short delay
+                    setTimeout(() => {
+                      bypassSendInterception = false;
+                      console.log("🔄 Reset bypass flag after successful send");
+                    }, 100);
+                  }, 500); // 500ms delay to ensure all updates are complete
+
+                } catch (error) {
+                  console.error("❌ Error during pre-send analysis:", error);
+
+                  // Still allow sending even if analysis fails
+                  setTimeout(() => {
+                    console.log("🚀 Triggering send despite analysis error");
+                    bypassSendInterception = true;
+
+                    if (originalOnClick) {
+                      originalOnClick.call(button, event);
+                    } else {
+                      const newEvent = new MouseEvent('click', {
+                        bubbles: true,
+                        cancelable: true,
+                        view: window
+                      });
+                      button.dispatchEvent(newEvent);
+                    }
+
+                    // Reset bypass flag after a short delay
+                    setTimeout(() => {
+                      bypassSendInterception = false;
+                      console.log("🔄 Reset bypass flag after error recovery");
+                    }, 100);
+                  }, 100);
+                }
+
+              }, true); // Use capture phase
+
+              button._hasClickInterceptor = true;
+              console.log("✅ Added click interceptor to send button");
+            }
+          });
+        } catch (error) {
+          console.log("❌ Error setting up send button interceptor:", error);
+        }
+      });
+    }
+
+    // Function to monitor for new send buttons (for dynamic content)
+    function setupSendButtonObserver() {
+      const websiteConfig = getCurrentWebsiteConfig();
+      if (!websiteConfig) {
+        return;
+      }
+
+      // Set up initial interceptors
+      interceptSendButtonClick();
+
+      const observer = new MutationObserver((mutations) => {
+        let newButtonsFound = false;
+
+        mutations.forEach((mutation) => {
+          mutation.addedNodes.forEach((node) => {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+              // Check if the added node itself is a send button
+              websiteConfig.selectors.forEach(selector => {
+                try {
+                  if (node.matches && node.matches(selector)) {
+                    console.log("🔍 New send button detected:", selector);
+                    newButtonsFound = true;
+                  }
+
+                  // Check if the added node contains send buttons
+                  const buttons = node.querySelectorAll ? node.querySelectorAll(selector) : [];
+                  if (buttons.length > 0) {
+                    console.log("🔍 New send buttons found in added content:", selector);
+                    newButtonsFound = true;
+                  }
+                } catch (error) {
+                  // Ignore selector errors
+                }
+              });
+            }
+          });
+        });
+
+        if (newButtonsFound) {
+          // Set up interceptors for new buttons
+          setTimeout(() => {
+            interceptSendButtonClick();
+          }, 100);
+        }
+
+        // Only block if we have pending API calls
+        if (pendingAPICallsCount > 0) {
+          blockSendButtons();
+        }
+      });
+
+      if (document.body) {
+        observer.observe(document.body, {
+          childList: true,
+          subtree: true
+        });
+        console.log("👀 Send button observer started with click interception");
+      }
+
+      return observer;
+    }
+
+    // Function to initialize all monitoring
+    function initializeMonitoring() {
+      // Initial setup
+      addInputMonitoring();
+
+      // Setup mutation observer for dynamic content (only if document.body exists)
+      if (document.body) {
+        setupInputObserver();
+
+        // Setup send button observer for AI websites
+        setupSendButtonObserver();
+      }
+    }
+
+    // Initialize monitoring when document is ready
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', initializeMonitoring);
+    } else {
+      initializeMonitoring();
+    }
+
+    // Re-run input monitoring after delays to catch late-loading elements
+    setTimeout(() => {
+      console.log("🔧 Re-running input monitoring after 2s...");
+      addInputMonitoring();
+    }, 2000);
+
+    setTimeout(() => {
+      console.log("🔧 Re-running input monitoring after 5s...");
+      addInputMonitoring();
+    }, 5000);
+
+    // Test function to verify input monitoring is working
+    function testInputMonitoring() {
+      try {
+        console.log("🧪 Testing input monitoring...");
+
+        if (!document) {
+          console.log("🧪 Document not available");
+          return;
+        }
+
+        const allInputs = document.querySelectorAll('input, textarea, [contenteditable]');
+        console.log(`🧪 Found ${allInputs.length} total input-like elements on page`);
+
+        allInputs.forEach((input, index) => {
+          console.log(`🧪 Input ${index + 1}:`, {
+            tag: input.tagName,
+            type: input.type || 'none',
+            id: input.id || 'no-id',
+            className: input.className || 'no-class',
+            placeholder: input.placeholder || 'no-placeholder',
+            hasEventListeners: input._hasInputMonitoring || false
+          });
+        });
+      } catch (error) {
+        console.error("🧪 Test function error:", error);
+      }
+    }
+
+    // Run test after page loads
+    setTimeout(testInputMonitoring, 3000);
+
+    // ======================
+    // SEND BUTTON BLOCKING FUNCTIONALITY
+    // ======================
+
+    // Function to get current website configuration
+    function getCurrentWebsiteConfig() {
+      const hostname = window.location.hostname.toLowerCase();
+
+      for (const [domain, config] of Object.entries(AI_WEBSITES)) {
+        if (hostname.includes(domain)) {
+          console.log("🌐 Detected AI website:", domain);
+          return config;
+        }
+      }
+
+      return null;
+    }
+
+    // Function to find and block send buttons
+    function blockSendButtons() {
+      const websiteConfig = getCurrentWebsiteConfig();
+      if (!websiteConfig) {
+        console.log("🌐 Not on a configured AI website, skipping send button blocking");
+        return;
+      }
+
+      console.log("🚫 ===== BLOCKING SEND BUTTONS =====");
+
+      let buttonsFound = 0;
+      websiteConfig.selectors.forEach(selector => {
+        try {
+          const buttons = document.querySelectorAll(selector);
+          buttons.forEach(button => {
+            if (!blockedSendButtons.has(button)) {
+              // Store original state
+              const originalDisabled = button.disabled;
+              const originalStyle = button.style.cssText;
+              const originalTitle = button.title;
+
+              // Disable the button
+              button.disabled = true;
+              button.style.opacity = '0.5';
+              button.style.cursor = 'not-allowed';
+              button.title = 'Waiting for text redaction to complete...';
+
+              // Store button reference and original state
+              blockedSendButtons.add(button);
+              button._originalState = {
+                disabled: originalDisabled,
+                style: originalStyle,
+                title: originalTitle
+              };
+
+              buttonsFound++;
+              console.log("🚫 Blocked send button:", selector);
+            }
+          });
+        } catch (error) {
+          console.log("🌐 Selector not found:", selector);
+        }
+      });
+
+      if (buttonsFound > 0) {
+        console.log(`🚫 Successfully blocked ${buttonsFound} send buttons`);
+      } else {
+        console.log("⚠️ No send buttons found to block");
+      }
+    }
+
+    // Function to unblock send buttons
+    function unblockSendButtons() {
+      console.log("✅ ===== UNBLOCKING SEND BUTTONS =====");
+
+      let buttonsUnblocked = 0;
+      blockedSendButtons.forEach(button => {
+        try {
+          if (button._originalState) {
+            // Restore original state
+            button.disabled = button._originalState.disabled;
+            button.style.cssText = button._originalState.style;
+            button.title = button._originalState.title;
+
+            delete button._originalState;
+            buttonsUnblocked++;
+          }
+        } catch (error) {
+          console.log("🌐 Error unblocking button:", error);
+        }
+      });
+
+      // Clear the blocked buttons set
+      blockedSendButtons.clear();
+
+      if (buttonsUnblocked > 0) {
+        console.log(`✅ Successfully unblocked ${buttonsUnblocked} send buttons`);
+      }
+    }
+
+    // Function to increment pending API calls and block buttons
+    function incrementPendingAPICalls() {
+      pendingAPICallsCount++;
+      console.log("📈 Pending API calls:", pendingAPICallsCount);
+
+      if (pendingAPICallsCount === 1) {
+        // First API call - block send buttons
+        blockSendButtons();
+      }
+    }
+
+    // Function to decrement pending API calls and unblock when done
+    function decrementPendingAPICalls() {
+      pendingAPICallsCount = Math.max(0, pendingAPICallsCount - 1);
+      console.log("📉 Pending API calls:", pendingAPICallsCount);
+
+      if (pendingAPICallsCount === 0) {
+        // All API calls complete - unblock send buttons
+        console.log("🎉 All API calls complete - unblocking send buttons");
+        unblockSendButtons();
+      }
+    }
+
+    // Add test functions for send button blocking
+    window.testSendButtonBlocking = function () {
+      console.log("🧪 ===== TESTING SEND BUTTON BLOCKING =====");
+      console.log("🧪 Current website:", window.location.hostname);
+      console.log("🧪 Pending API calls:", pendingAPICallsCount);
+
+      // Simulate API call
+      incrementPendingAPICalls();
+
+      setTimeout(() => {
+        console.log("🧪 Simulating API completion...");
+        decrementPendingAPICalls();
+      }, 3000);
+    };
+
+    window.testMultipleAPICalls = function () {
+      console.log("🧪 ===== TESTING MULTIPLE API CALLS =====");
+
+      // Simulate 3 API calls
+      incrementPendingAPICalls();
+      incrementPendingAPICalls();
+      incrementPendingAPICalls();
+
+      console.log("🧪 Started 3 API calls, will complete them one by one...");
+
+      setTimeout(() => {
+        console.log("🧪 Completing API call 1/3");
+        decrementPendingAPICalls();
+      }, 2000);
+
+      setTimeout(() => {
+        console.log("🧪 Completing API call 2/3");
+        decrementPendingAPICalls();
+      }, 4000);
+
+      setTimeout(() => {
+        console.log("🧪 Completing API call 3/3");
+        decrementPendingAPICalls();
+      }, 6000);
+    };
+
+    window.getSendButtonStatus = function () {
+      console.log("📊 ===== SEND BUTTON STATUS =====");
+      console.log("📊 Pending API calls:", pendingAPICallsCount);
+      console.log("📊 Blocked buttons count:", blockedSendButtons.size);
+      console.log("📊 Current website config:", getCurrentWebsiteConfig());
+
+      const websiteConfig = getCurrentWebsiteConfig();
+      if (websiteConfig) {
+        websiteConfig.selectors.forEach(selector => {
+          const buttons = document.querySelectorAll(selector);
+          console.log(`📊 Found ${buttons.length} buttons for selector: ${selector}`);
+          buttons.forEach((button, index) => {
+            console.log(`📊   Button ${index + 1}: disabled=${button.disabled}, hasInterceptor=${!!button._hasClickInterceptor}`);
+          });
+        });
+      }
+    };
+
+    // Add test function for the new send button interception functionality
+    window.testSendButtonInterception = function () {
+      console.log("🧪 ===== TESTING SEND BUTTON INTERCEPTION =====");
+
+      // Add some test text to an input field
+      const testInput = document.querySelector('textarea') || document.querySelector('input[type="text"]') || document.querySelector('[contenteditable="true"]');
+      if (testInput) {
+        const testText = "My email is john.doe@example.com and my phone is 555-123-4567";
+        if (testInput.value !== undefined) {
+          testInput.value = testText;
+        } else {
+          testInput.textContent = testText;
+        }
+        testInput.dispatchEvent(new Event('input', { bubbles: true }));
+        console.log("🧪 Added test sensitive data to input field");
+
+        // Try to find and click send button
+        const websiteConfig = getCurrentWebsiteConfig();
+        if (websiteConfig) {
+          websiteConfig.selectors.forEach(selector => {
+            const button = document.querySelector(selector);
+            if (button) {
+              console.log("🧪 Found send button, testing click interception...");
+              console.log("🧪 Button has interceptor:", !!button._hasClickInterceptor);
+              button.click();
+              return;
+            }
+          });
+          console.log("🧪 No send button found for current website");
+        } else {
+          console.log("🧪 Current website not configured for send button interception");
+        }
+      } else {
+        console.log("🧪 No input field found for testing");
+      }
+    };
+
     // Initialize content analysis - auto-trigger once per page
     console.log("🔧 Initializing content analysis...");
 
@@ -264,11 +1191,22 @@
       });
     });
 
-    observer.observe(document.body, { childList: true, subtree: true });
+    // Ensure document.body exists before observing
+    if (document.body) {
+      observer.observe(document.body, { childList: true, subtree: true });
+    } else {
+      // Wait for document.body to be available
+      document.addEventListener('DOMContentLoaded', () => {
+        if (document.body) {
+          observer.observe(document.body, { childList: true, subtree: true });
+        }
+      });
+    }
 
     // Listen for navigation events (for SPAs)
     window.addEventListener("popstate", handleNavigation);
 
+
     // Check for URL changes periodically (for SPAs)
     setInterval(handleNavigation, 2000);
   }
diff --git a/Authenticator/repo/manifest.json b/Authenticator/repo/manifest.json
index dffcd56ee..d07149489 100644
--- a/Authenticator/repo/manifest.json
+++ b/Authenticator/repo/manifest.json
@@ -1,8 +1,8 @@
 {
   "manifest_version": 3,
-  "name": "SAML Authenticator & Sensitive Content Detector",
-  "version": "1.0.0",
-  "description": "Handles Okta SAML authentication and detects sensitive content using AI",
+  "name": "SAML Authenticator & AI Redaction Guard",
+  "version": "1.1.0",
+  "description": "Handles Okta SAML authentication and automatically redacts sensitive data on AI websites (ChatGPT, Gemini, Claude, etc.)",
   "icons": {
     "16": "Okta.png",
     "32": "Okta.png",
@@ -17,7 +17,15 @@
   "host_permissions": [
     "https://integrator-2373294.okta.com/*",
     "https://*.okta.com/*",
-    "https://generativelanguage.googleapis.com/*"
+    "https://generativelanguage.googleapis.com/*",
+    "https://chatgpt.com/*",
+    "https://*.openai.com/*",
+    "https://gemini.google.com/*",
+    "https://bard.google.com/*",
+    "https://perplexity.ai/*",
+    "https://claude.ai/*",
+    "https://*.anthropic.com/*",
+    "https://poe.com/*"
   ],
   "action": {
     "default_popup": "popup.html",
@@ -36,7 +44,19 @@
       "resources": [
         "auth-success.html",
         "auth-success.js",
-        "popup.html"
+        "popup.html",
+        "public/libs/xregexp.js",
+        "public/ptr/apipatterns.js",
+        "public/ptr/apiPatterns_new.js",
+        "public/ptr/piiPatterns.js",
+        "public/ptr/fiPatterns.js",
+        "public/ptr/fiPatterns_new.js",
+        "public/ptr/cryptoPatterns.js",
+        "public/ptr/cryptoPatterns_new.js",
+        "public/ptr/medPatterns.js",
+        "public/ptr/medPatterns_new.js",
+        "public/ptr/networkPatterns.js",
+        "public/ptr/networkPatterns_new.js"
       ],
       "matches": [
         "<all_urls>"
diff --git a/Authenticator/repo/public/libs/xregexp.js b/Authenticator/repo/public/libs/xregexp.js
new file mode 100644
index 000000000..d3b5d4bb4
--- /dev/null
+++ b/Authenticator/repo/public/libs/xregexp.js
@@ -0,0 +1,24 @@
+// Minimal XRegExp replacement for the extension
+function XRegExp(pattern, flags) {
+  // If pattern is already a string, create a regular expression
+  if (typeof pattern === 'string') {
+    return new RegExp(pattern, flags);
+  }
+  
+  // If pattern is already a RegExp, return it as is
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  
+  // Fallback
+  return new RegExp(pattern, flags);
+}
+
+// Make XRegExp available globally
+if (typeof window !== 'undefined') {
+  window.XRegExp = XRegExp;
+} else if (typeof global !== 'undefined') {
+  global.XRegExp = XRegExp;
+} else if (typeof self !== 'undefined') {
+  self.XRegExp = XRegExp;
+}
\ No newline at end of file
diff --git a/Authenticator/repo/public/ptr/apiPatterns_new.js b/Authenticator/repo/public/ptr/apiPatterns_new.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/Authenticator/repo/public/ptr/apipatterns.js b/Authenticator/repo/public/ptr/apipatterns.js
new file mode 100644
index 000000000..f5f265391
--- /dev/null
+++ b/Authenticator/repo/public/ptr/apipatterns.js
@@ -0,0 +1,1257 @@
+const apiPatterns = {
+
+
+   
+googleAPIKey: {
+    type: "Google API Key",
+    pattern: XRegExp('\\b(?:AIZA|aiza|AiZA|aIZA|Aiza|aiZA|AIza|AiZa)[0-9A-Za-z\\-_]{25,43}\\b'),
+    description: "Matches Google API keys prefixed with 'AIza'.",
+    tags: ["Google", "API Key"]
+},
+
+
+adobeSignAPIKey: {
+    type: "Adobe Sign API Key",
+    pattern: XRegExp('^SIGN-[A-Za-z0-9]{20,25}$'),
+    description: "Matches Adobe Sign API keys starting with 'SIGN-'.",
+    tags: ["Adobe", "API Key"]
+},
+
+
+adobeAnalyticsAPIKey: {
+    type: "Adobe Analytics API Key",
+    pattern: XRegExp('^AKEY-[A-Za-z0-9]{20,25}$'),
+    description: "Matches Adobe Analytics API keys starting with 'AKEY-'.",
+    tags: ["Adobe", "API Key"]
+},
+
+
+adobeClientID: {
+    type: "Adobe API Key (Client ID)",
+    pattern: XRegExp('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'),
+    description: "Matches Adobe Client ID in UUID format.",
+    tags: ["Adobe", "API Key"]
+},
+
+
+ablyAPIKey: {
+    type: "Ably API Key",
+    pattern: XRegExp('^ably_[a-zA-Z0-9]{32}$'),
+    description: "Matches Ably API keys prefixed with 'ably_'.",
+    tags: ["Ably", "API Key"]
+},
+
+
+accuWeatherAPIKey: {
+    type: "AccuWeather API Key",
+    pattern: XRegExp('^[0-9A-Za-z]{32}$'),
+    description: "Matches 32-character AccuWeather API keys.",
+    tags: ["AccuWeather", "API Key"]
+},
+
+
+airtableAPIKey: {
+    type: "Airtable API Key",
+    pattern: XRegExp('^key[A-Za-z0-9]{14}$'),
+    description: "Matches Airtable API keys prefixed with 'key'.",
+    tags: ["Airtable", "API Key"]
+},
+
+
+algoliaAPIKey: {
+    type: "Algolia API Key",
+    pattern: XRegExp('^[a-f0-9]{32}$'),
+    description: "Matches Algolia API keys in hexadecimal format.",
+    tags: ["Algolia", "API Key"]
+},
+
+
+agoraAPIKey: {
+    type: "Agora API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches 32-character Agora API keys.",
+    tags: ["Agora", "API Key"]
+},
+
+
+awsAccessID: {
+    type: "AWS Access ID Key",
+    pattern: XRegExp('\\bAKIA[0-9A-Z]{16}\\b'),
+    description: "Matches AWS Access ID Keys starting with 'AKIA'.",
+    tags: ["AWS", "Access Key"]
+},
+
+
+awsSecretKey: {
+    type: "AWS Secret Key",
+    pattern: XRegExp('\\b[0-9a-zA-Z/+]{40}\\b'),
+    description: "Matches 40-character AWS Secret Keys.",
+    tags: ["AWS", "Secret Key"]
+},
+
+
+amazonAuthToken: {
+    type: "Amazon Auth Token",
+    pattern: XRegExp('^amzn\\.mws\\.[0-9a-f]{8}-[0-9a-f]{4}-10-[0-9a-f]{4}-[0-9a-f]{12}$'),
+    description: "Matches Amazon Auth Tokens in a specific pattern.",
+    tags: ["Amazon", "Auth Token"]
+},
+
+
+amplitudeAPIKey: {
+    type: "Amplitude API Key",
+    pattern: XRegExp('^amp_[A-Za-z0-9]{20,32}$'),
+    description: "Matches Amplitude API keys prefixed with 'amp_'.",
+    tags: ["Amplitude", "API Key"]
+},
+
+
+applePrivateKey: {
+    type: "Apple Private Key",
+    pattern: XRegExp('^-----BEGIN PRIVATE KEY-----[A-Za-z0-9+/=\\s]+-----END PRIVATE KEY-----$'),
+    description: "Matches Apple Private Keys in PEM format.",
+    tags: ["Apple", "Private Key"]
+},
+
+
+atlassianAPIKey: {
+    type: "Atlassian API Key",
+    pattern: XRegExp('^atl_[a-zA-Z0-9]{24,40}$'),
+    description: "Matches Atlassian API keys prefixed with 'atl_'.",
+    tags: ["Atlassian", "API Key"]
+},
+
+
+autodeskAPIKey: {
+    type: "Autodesk API Key",
+    pattern: XRegExp('^ads[A-Za-z0-9]{20,32}$'),
+    description: "Matches Autodesk API keys prefixed with 'ads'.",
+    tags: ["Autodesk", "API Key"]
+},
+
+
+autopilotAPIKey: {
+    type: "Autopilot API Key",
+    pattern: XRegExp('^AP-[A-Za-z0-9]{30}$'),
+    description: "Matches Autopilot API keys prefixed with 'AP-'.",
+    tags: ["Autopilot", "API Key"]
+},
+
+
+basecampAPIKey: {
+    type: "Basecamp API Key",
+    pattern: XRegExp('^BC[A-Za-z0-9]{24}$'),
+    description: "Matches Basecamp API keys prefixed with 'BC'.",
+    tags: ["Basecamp", "API Key"]
+},
+
+
+benchlingAPIKey: {
+    type: "Benchling API Key",
+    pattern: XRegExp('^bench_[A-Za-z0-9]{32}$'),
+    description: "Matches Benchling API keys prefixed with 'bench_'.",
+    tags: ["Benchling", "API Key"]
+},
+
+
+bitbucketAPIKey: {
+    type: "Bitbucket API Key",
+    pattern: XRegExp('^bitbucket_[A-Za-z0-9]{20,30}$'),
+    description: "Matches Bitbucket API keys prefixed with 'bitbucket_'.",
+    tags: ["Bitbucket", "API Key"]
+},
+
+
+boxDeveloperToken: {
+    type: "Box Developer Token",
+    pattern: XRegExp('^[A-Za-z0-9_-]{64}$'),
+    description: "Matches 64-character Box Developer Tokens.",
+    tags: ["Box", "Developer Token"]
+},
+
+
+calendlyAPIKey: {
+    type: "Calendly API Key",
+    pattern: XRegExp('^api_key-[a-zA-Z0-9]{40}$'),
+    description: "Matches Calendly API keys prefixed with 'api_key-'.",
+    tags: ["Calendly", "API Key"]
+},
+
+
+ciscoWebexAPIKey: {
+    type: "Cisco Webex API Key",
+    pattern: XRegExp('^MC[A-Za-z0-9_-]{20,40}$'),
+    description: "Matches Cisco Webex API keys prefixed with 'MC'.",
+    tags: ["Cisco", "Webex", "API Key"]
+},
+
+
+clarityAIKey: {
+    type: "Clarity AI API Key",
+    pattern: XRegExp('^[a-f0-9]{36}$'),
+    description: "Matches 36-character Clarity AI API keys.",
+    tags: ["Clarity AI", "API Key"]
+},
+
+
+clickupAPIKey: {
+    type: "ClickUp API Key",
+    pattern: XRegExp('^cl_[A-Za-z0-9]{32}$'),
+    description: "Matches ClickUp API keys prefixed with 'cl_'.",
+    tags: ["ClickUp", "API Key"]
+},
+
+
+cloudflareAPIToken: {
+    type: "Cloudflare API Token",
+    pattern: XRegExp('^[A-Fa-f0-9]{32}$'),
+    description: "Matches 32-character Cloudflare API tokens.",
+    tags: ["Cloudflare", "API Token"]
+},
+
+
+cloudinaryAPIKey: {
+    type: "Cloudinary API Key",
+    pattern: XRegExp('^CLOUDK-[A-Za-z0-9_-]{20}$'),
+    description: "Matches Cloudinary API keys prefixed with 'CLOUDK-'.",
+    tags: ["Cloudinary", "API Key"]
+},
+
+
+cockroachDBAPIKey: {
+    type: "CockroachDB API Key",
+    pattern: XRegExp('^cockroach_[A-Za-z0-9]{24,40}$'),
+    description: "Matches CockroachDB API keys prefixed with 'cockroach_'.",
+    tags: ["CockroachDB", "API Key"]
+},
+
+
+codaAPIToken: {
+    type: "Coda API Token",
+    pattern: XRegExp('^[A-Za-z0-9]{40}$'),
+    description: "Matches 40-character Coda API tokens.",
+    tags: ["Coda", "API Token"]
+},
+
+
+coinbaseAPIKey: {
+    type: "Coinbase API Key",
+    pattern: XRegExp('^[a-zA-Z0-9]{32}$'),
+    description: "Matches 32-character Coinbase API keys.",
+    tags: ["Coinbase", "API Key"]
+},
+
+
+contentfulDeliveryAPIKey: {
+    type: "Contentful Delivery API Key",
+    pattern: XRegExp('^[a-zA-Z0-9_-]{43}$'),
+    description: "Matches 43-character Contentful API keys.",
+    tags: ["Contentful", "Delivery API Key"]
+},
+
+
+courierAPIKey: {
+    type: "Courier API Key",
+    pattern: XRegExp('^courier_[a-zA-Z0-9]{50}$'),
+    description: "Matches Courier API keys prefixed with 'courier_'.",
+    tags: ["Courier", "API Key"]
+},
+
+
+dashlaneAPIKey: {
+    type: "Dashlane API Key",
+    pattern: XRegExp('^dashlane_[A-Za-z0-9]{24,}$'),
+    description: "Matches Dashlane API keys prefixed with 'dashlane_'.",
+    tags: ["Dashlane", "API Key"]
+},
+
+
+datadogAPIKey: {
+    type: "Datadog API Key",
+    pattern: XRegExp('^DDOG[a-fA-F0-9]{28}$'),
+    description: "Matches Datadog API keys prefixed with 'DDOG'.",
+    tags: ["Datadog", "API Key"]
+},
+
+
+dailymotionAPIKey: {
+    type: "Dailymotion API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{40}$'),
+    description: "Matches 40-character Dailymotion API keys.",
+    tags: ["Dailymotion", "API Key"]
+},
+
+
+deezerAPIKey: {
+    type: "Deezer API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches 32-character Deezer API keys.",
+    tags: ["Deezer", "API Key"]
+},
+
+
+dockerAPIToken: {
+    type: "Docker API Token",
+    pattern: XRegExp('^docker_[A-Za-z0-9]{32}$'),
+    description: "Matches Docker API tokens prefixed with 'docker_'.",
+    tags: ["Docker", "API Token"]
+},
+
+
+dockerHubAPIToken: {
+    type: "Docker Hub API Token",
+    pattern: XRegExp('^[0-9A-Za-z_-]{32}$'),
+    description: "Matches 32-character Docker Hub API tokens.",
+    tags: ["Docker Hub", "API Token"]
+},
+
+
+docusignAPIKey: {
+    type: "Docusign API Key",
+    pattern: XRegExp('^DS[A-Za-z0-9]{20}$'),
+    description: "Matches Docusign API keys prefixed with 'DS'.",
+    tags: ["Docusign", "API Key"]
+},
+
+
+driftAPIToken: {
+    type: "Drift API Token",
+    pattern: XRegExp('^drift_[A-Za-z0-9]{40}$'),
+    description: "Matches Drift API tokens prefixed with 'drift_'.",
+    tags: ["Drift", "API Token"]
+},
+
+
+dropboxAPIKey: {
+    type: "Dropbox API Key",
+    pattern: XRegExp('^[a-z0-9]{40,50}$'),
+    description: "Matches Dropbox API keys, typically 40-50 characters.",
+    tags: ["Dropbox", "API Key"]
+},
+
+
+duckduckgoAPIKey: {
+    type: "DuckDuckGo API Key",
+    pattern: XRegExp('^duck[A-Za-z0-9]{20}$'),
+    description: "Matches DuckDuckGo API keys prefixed with 'duck'.",
+    tags: ["DuckDuckGo", "API Key"]
+},
+
+
+ebayAPIKey: {
+    type: "eBay API Key",
+    pattern: XRegExp('^[0-9a-zA-Z]{24}$'),
+    description: "Matches 24-character eBay API keys.",
+    tags: ["eBay", "API Key"]
+},
+
+
+elasticCloudAPIKey: {
+    type: "Elastic Cloud API Key",
+    pattern: XRegExp('^[a-zA-Z0-9]{32}$'),
+    description: "Matches Elastic Cloud API keys, typically 32 characters.",
+    tags: ["Elastic Cloud", "API Key"]
+},
+
+
+envoyAPIKey: {
+    type: "Envoy API Key",
+    pattern: XRegExp('^env_[A-Za-z0-9]{40}$'),
+    description: "Matches Envoy API keys prefixed with 'env_'.",
+    tags: ["Envoy", "API Key"]
+},
+
+
+etsyAPIKey: {
+    type: "Etsy API Key",
+    pattern: XRegExp('^key_[A-Za-z0-9]{32}$'),
+    description: "Matches Etsy API keys prefixed with 'key_'.",
+    tags: ["Etsy", "API Key"]
+},
+
+
+eventbriteAPIKey: {
+    type: "Eventbrite API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches Eventbrite API keys, typically 32 characters.",
+    tags: ["Eventbrite", "API Key"]
+},
+
+
+expensifyAPIKey: {
+    type: "Expensify API Key",
+    pattern: XRegExp('^exp_[A-Za-z0-9]{40}$'),
+    description: "Matches Expensify API keys prefixed with 'exp_'.",
+    tags: ["Expensify", "API Key"]
+},
+
+
+facebookGraphAPIToken: {
+    type: "Facebook Graph API Token",
+    pattern: XRegExp('^EAAG[a-zA-Z0-9]{30,60}$'),
+    description: "Matches Facebook Graph API tokens prefixed with 'EAAG'.",
+    tags: ["Facebook", "Graph API", "Token"]
+},
+
+
+facebookAccessToken: {
+    type: "Facebook Access Token",
+    pattern: XRegExp('^EAACEdEose0cBA[0-9A-Za-z]+$'),
+    description: "Matches Facebook Access Tokens with common prefix.",
+    tags: ["Facebook", "Access Token"]
+},
+
+
+figmaAPIToken: {
+    type: "Figma API Token",
+    pattern: XRegExp('^figd_[a-f0-9]{32,64}$'),
+    description: "Matches Figma API tokens prefixed with 'figd_'.",
+    tags: ["Figma", "API Token"]
+},
+
+
+firebaseWebAPIKey: {
+    type: "Firebase Web API Key",
+    pattern: XRegExp('^AAAA[A-Za-z0-9_-]{20,50}$'),
+    description: "Matches Firebase Web API keys prefixed with 'AAAA'.",
+    tags: ["Firebase", "Web API Key"]
+},
+
+
+flexportAPIKey: {
+    type: "Flexport API Key",
+    pattern: XRegExp('(?<![a-zA-Z0-9])flex[A-Za-z0-9]{20,30}(?![a-zA-Z0-9])'),
+    description: "Matches Flexport API keys prefixed with 'flex' when appearing as standalone tokens.",
+    tags: ["Flexport", "API Key"]
+},
+
+
+freshdeskAPIKey: {
+    type: "Freshdesk API Key",
+    pattern: XRegExp('(?<![a-zA-Z0-9])[A-Za-z0-9]{32}(?![a-zA-Z0-9])'),
+    description: "Matches 32-character Freshdesk API keys when appearing as standalone tokens.",
+    tags: ["Freshdesk", "API Key"]
+},
+
+
+freshserviceAPIKey: {
+    type: "Freshservice API Key",
+    pattern: XRegExp('(?<![a-zA-Z0-9])fs_[A-Za-z0-9]{32}(?![a-zA-Z0-9])'),
+    description: "Matches Freshservice API keys prefixed with 'fs_' when appearing as standalone tokens.",
+    tags: ["Freshservice", "API Key"]
+},
+
+
+
+ghostAdminAPIKey: {
+    type: "Ghost Admin API Key",
+    pattern: XRegExp('\\b[0-9a-zA-Z]{24}:[0-9a-fA-F]{64}\\b'),
+    description: "Matches Ghost Admin API keys, with a 24-character alphanumeric ID and a 64-character hexadecimal secret separated by a colon.",
+    tags: ["Ghost", "Admin API Key"]
+},
+
+githubPersonalAccessToken: {
+    type: "GitHub Personal Access Token (Classic)",
+    pattern: XRegExp('(?:^|\\s|[\'"({\\[])(ghp_[a-zA-Z0-9]{36})(?=$|\\s|[\'")},\\]])'),
+    description: "Matches GitHub Personal Access Tokens prefixed with 'ghp_' only as standalone tokens.",
+    tags: ["GitHub", "Personal Access Token"]
+},
+
+
+githubFineGrainedToken: {
+    type: "GitHub Personal Access Token (Fine-Grained)",
+    pattern: XRegExp('(?:^|\\s|[\'"({\\[])(github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59})(?=$|\\s|[\'")},\\]])'),
+    description: "Matches fine-grained GitHub PATs prefixed with 'github_pat_' only as standalone tokens.",
+    tags: ["GitHub", "Personal Access Token"]
+},
+
+
+githubOAuthToken: {
+    type: "GitHub OAuth 2.0 Access Token",
+    pattern: XRegExp('(?:^|\\s|[\'"({\\[])(gho_[a-zA-Z0-9]{36})(?=$|\\s|[\'")},\\]])'),
+    description: "Matches GitHub OAuth Access Tokens prefixed with 'gho_' only as standalone tokens.",
+    tags: ["GitHub", "OAuth Token"]
+},
+
+
+githubUserToServerToken: {
+    type: "GitHub User-to-Server Access Token",
+    pattern: XRegExp('(?:^|\\s|[\'"({\\[])(ghu_[a-zA-Z0-9]{36})(?=$|\\s|[\'")},\\]])'),
+    description: "Matches GitHub User-to-Server Access Tokens prefixed with 'ghu_' only as standalone tokens.",
+    tags: ["GitHub", "Access Token"]
+},
+
+
+githubServerToServerToken: {
+    type: "GitHub Server-to-Server Access Token",
+    pattern: XRegExp('(?:^|\\s|[\'"({\\[])(ghs_[a-zA-Z0-9]{36})(?=$|\\s|[\'")},\\]])'),
+    description: "Matches GitHub Server-to-Server Access Tokens prefixed with 'ghs_' only as standalone tokens.",
+    tags: ["GitHub", "Server Access Token"]
+},
+
+
+githubRefreshToken: {
+    type: "GitHub Refresh Token",
+    pattern: XRegExp('(?:^|\\s|[\'"({\\[])(ghr_[a-zA-Z0-9]{36})(?=$|\\s|[\'")},\\]])'),
+    description: "Matches GitHub Refresh Tokens prefixed with 'ghr_' only as standalone tokens.",
+    tags: ["GitHub", "Refresh Token"]
+},
+
+
+
+
+gitkrakenAPIKey: {
+    type: "GitKraken API Key",
+    pattern: XRegExp('(?:\\b|")krkn_[A-Za-z0-9]{32}(?:\\b|")'),
+    description: "Matches GitKraken API keys prefixed with 'krkn_' when appearing as standalone tokens.",
+    tags: ["GitKraken", "API Key"]
+},
+
+
+gitlabAPIKey: {
+    type: "GitLab API Key",
+    pattern: XRegExp('(?:\\b|")glpat-[A-Za-z0-9-_]{20}(?:\\b|")'),
+    description: "Matches GitLab Personal Access Tokens prefixed with 'glpat-' when appearing as standalone tokens.",
+    tags: ["GitLab", "API Key"]
+},
+
+
+googleOAuthSecretKey: {
+    type: "Google OAuth 2.0 Secret Key",
+    pattern: XRegExp('^[0-9a-zA-Z-_]{24}$'),
+    description: "Matches Google OAuth Secret Keys, 24 characters long.",
+    tags: ["Google", "OAuth", "Secret Key"]
+},
+
+
+googleOAuthAuthCode: {
+    type: "Google OAuth 2.0 Auth Code",
+    pattern: XRegExp('^4\\/[0-9A-Za-z-_]+$'),
+    description: "Matches Google OAuth Authorization Codes prefixed with '4/'.",
+    tags: ["Google", "OAuth", "Auth Code"]
+},
+
+
+googleOAuthRefreshToken: {
+    type: "Google OAuth 2.0 Refresh Token",
+    pattern: XRegExp('^1\\/[0-9A-Za-z-]{43}$|^1\\/[0-9A-Za-z-]{64}$'),
+    description: "Matches Google OAuth Refresh Tokens prefixed with '1/'.",
+    tags: ["Google", "OAuth", "Refresh Token"]
+},
+
+
+googleOAuthAccessToken: {
+    type: "Google OAuth 2.0 Access Token",
+    pattern: XRegExp('^ya29\\.[0-9A-Za-z-_]+$'),
+    description: "Matches Google OAuth Access Tokens prefixed with 'ya29.'.",
+    tags: ["Google", "OAuth", "Access Token"]
+},
+
+
+googleCloudAPIKey: {
+    type: "Google Cloud API Key",
+    pattern: XRegExp('^[A-Za-z0-9_]{21}--[A-Za-z0-9_]{8}$'),
+    description: "Matches Google Cloud API keys in a specific format.",
+    tags: ["Google Cloud", "API Key"]
+},
+
+
+googleCloudOAuthToken: {
+    type: "Google Cloud OAuth 2.0 Token",
+    pattern: XRegExp('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'),
+    description: "Matches Google Cloud OAuth tokens in UUID format.",
+    tags: ["Google Cloud", "OAuth Token"]
+},
+
+
+greenhouseAPIKey: {
+    type: "Greenhouse API Key",
+    pattern: XRegExp('^gh[A-Za-z0-9]{32}$'),
+    description: "Matches Greenhouse API keys prefixed with 'gh'.",
+    tags: ["Greenhouse", "API Key"]
+},
+
+
+grooveAPIKey: {
+    type: "Groove API Key",
+    pattern: XRegExp('^grv_[A-Za-z0-9]{40}$'),
+    description: "Matches Groove API keys prefixed with 'grv_'.",
+    tags: ["Groove", "API Key"]
+},
+
+
+hackerrankAPIKey: {
+    type: "HackerRank API Key",
+    pattern: XRegExp('^HCKR[a-zA-Z0-9]{32}$'),
+    description: "Matches HackerRank API keys prefixed with 'HCKR'.",
+    tags: ["HackerRank", "API Key"]
+},
+
+
+hellosignAPIKey: {
+    type: "HelloSign API Key",
+    pattern: XRegExp('^HS[A-Za-z0-9_-]{38}$'), 
+    description: "Matches 40-character HelloSign API keys prefixed with 'HS'.",
+    tags: ["HelloSign", "API Key"]
+
+},
+
+
+herokuAPIKey: {
+    type: "Heroku API Key",
+    pattern: XRegExp('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'),
+    description: "Matches Heroku API keys in UUID format.",
+    tags: ["Heroku", "API Key"]
+},
+
+
+honeybookAPIKey: {
+    type: "HoneyBook API Key",
+    pattern: XRegExp('^Hny[A-Za-z0-9]{30}$'),
+    description: "Matches HoneyBook API keys prefixed with 'Hny'.",
+    tags: ["HoneyBook", "API Key"]
+},
+
+
+hootsuiteAPIKey: {
+    type: "Hootsuite API Key",
+    pattern: XRegExp('^Hoot[A-Za-z0-9]{30}$'),
+    description: "Matches Hootsuite API keys prefixed with 'Hoot'.",
+    tags: ["Hootsuite", "API Key"]
+},
+
+
+hubspotAPIKey: {
+    type: "HubSpot API Key",
+    pattern: XRegExp('^pat-[a-zA-Z0-9]{32}$'),
+    description: "Matches HubSpot API keys prefixed with 'pat-'.",
+    tags: ["HubSpot", "API Key"]
+},
+
+
+ibmCloudAPIKey: {
+    type: "IBM Cloud API Key",
+    pattern: XRegExp('^[A-Za-z0-9_-]{64}$'),
+    description: "Matches IBM Cloud API keys, typically 64 characters.",
+    tags: ["IBM Cloud", "API Key"]
+},
+
+
+insightlyAPIKey: {
+    type: "Insightly API Key",
+    pattern: XRegExp('^ins[A-Za-z0-9]{40}$'),
+    description: "Matches Insightly API keys prefixed with 'ins'.",
+    tags: ["Insightly", "API Key"]
+},
+
+
+intercomAccessToken: {
+    type: "Intercom Access Token",
+    pattern: XRegExp('^int_[A-Za-z0-9]{64}$'),
+    description: "Matches Intercom access tokens prefixed with 'int_'.",
+    tags: ["Intercom", "Access Token"]
+},
+
+
+instagramOAuthToken: {
+    type: "Instagram OAuth 2.0 Token",
+    pattern: XRegExp('^[0-9a-fA-F]{7}\\.[0-9a-fA-F]{32}$'),
+    description: "Matches Instagram OAuth 2.0 tokens in a specific format.",
+    tags: ["Instagram", "OAuth Token"]
+},
+
+ipinfoAPIKey: {
+    type: "IPinfo API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{20}$'),
+    description: "Matches 20-character IPinfo API keys.",
+    tags: ["IPinfo", "API Key"]
+},
+
+
+itunesAPIKey: {
+    type: "iTunes API Key",
+    pattern: XRegExp('^IT-[A-Za-z0-9]{20}$'),
+    description: "Matches iTunes API keys prefixed with 'IT-'.",
+    tags: ["iTunes", "API Key"]
+},
+
+
+ivantiAPIKey: {
+    type: "Ivanti API Key",
+    pattern: XRegExp('^[a-zA-Z0-9]{24}$'),
+    description: "Matches 24-character Ivanti API keys.",
+    tags: ["Ivanti", "API Key"]
+},
+
+
+kajabiAPIKey: {
+    type: "Kajabi API Key",
+    pattern: XRegExp('^kaj_[A-Za-z0-9]{32}$'),
+    description: "Matches Kajabi API keys prefixed with 'kaj_'.",
+    tags: ["Kajabi", "API Key"]
+},
+
+
+keeperAPIKey: {
+    type: "Keeper API Key",
+    pattern: XRegExp('^keeper_[A-Za-z0-9]{32}$'),
+    description: "Matches Keeper API keys prefixed with 'keeper_'.",
+    tags: ["Keeper", "API Key"]
+},
+
+
+klarnaAPIKey: {
+    type: "Klarna API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches 32-character Klarna API keys.",
+    tags: ["Klarna", "API Key"]
+},
+
+
+kustomerAPIKey: {
+    type: "Kustomer API Key",
+    pattern: XRegExp('^kust_[A-Za-z0-9]{32}$'),
+    description: "Matches Kustomer API keys prefixed with 'kust_'.",
+    tags: ["Kustomer", "API Key"]
+},
+
+
+laterAPIKey: {
+    type: "Later API Key",
+    pattern: XRegExp('^later[A-Za-z0-9]{20,30}$'),
+    description: "Matches Later API keys prefixed with 'later'.",
+    tags: ["Later", "API Key"]
+},
+
+
+leverAPIKey: {
+    type: "Lever API Key",
+    pattern: XRegExp('^lever_[A-Za-z0-9]{32}$'),
+    description: "Matches Lever API keys prefixed with 'lever_'.",
+    tags: ["Lever", "API Key"]
+},
+
+
+linodeAPIToken: {
+    type: "Linode API Token",
+    pattern: XRegExp('^[A-Za-z0-9]{64}$'),
+    description: "Matches 64-character Linode API tokens.",
+    tags: ["Linode", "API Token"]
+},
+
+
+luluAPIKey: {
+    type: "Lulu API Key",
+    pattern: XRegExp('^lulu_[A-Za-z0-9]{32}$'),
+    description: "Matches Lulu API keys prefixed with 'lulu_'.",
+    tags: ["Lulu", "API Key"]
+},
+
+
+mailchimpAccessToken: {
+    type: "MailChimp Access Token",
+    pattern: XRegExp('^[0-9a-f]{32}-us[0-9]{1,2}$'),
+    description: "Matches MailChimp access tokens with region suffix.",
+    tags: ["MailChimp", "Access Token"]
+},
+
+
+mattermostAccessToken: {
+    type: "Mattermost Access Token",
+    pattern: XRegExp('^matter[A-Za-z0-9]{32}$'),
+    description: "Matches Mattermost access tokens prefixed with 'matter'.",
+    tags: ["Mattermost", "Access Token"]
+},
+
+
+azureClientID: {
+    type: "Azure Client ID",
+    pattern: XRegExp('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'),
+    description: "Matches Azure Client IDs in UUID format.",
+    tags: ["Microsoft Azure", "Client ID"]
+},
+
+
+microsoftBingAPIKey: {
+    type: "Microsoft Bing Search API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches 32-character Microsoft Bing API keys.",
+    tags: ["Microsoft Bing", "API Key"]
+},
+
+
+miroAPIToken: {
+    type: "Miro API Token",
+    pattern: XRegExp('^miro_[A-Za-z0-9]{32}$'),
+    description: "Matches Miro API tokens prefixed with 'miro_'.",
+    tags: ["Miro", "API Token"]
+},
+
+
+mondayAPIKey: {
+    type: "Monday.com API Key",
+    pattern: XRegExp('^api_key=[a-zA-Z0-9]{40}$'),
+    description: "Matches Monday.com API keys prefixed with 'api_key='. ",
+    tags: ["Monday.com", "API Key"]
+},
+
+
+moosendAPIKey: {
+    type: "Moosend API Key",
+    pattern: XRegExp('^moose_[A-Za-z0-9]{40}$'),
+    description: "Matches Moosend API keys prefixed with 'moose_'.",
+    tags: ["Moosend", "API Key"]
+},
+
+
+newRelicAPIKey: {
+    type: "New Relic API Key",
+    pattern: XRegExp('^NRRA-[a-zA-Z0-9]{32}$'),
+    description: "Matches New Relic API keys prefixed with 'NRRA-'.",
+    tags: ["New Relic", "API Key"]
+},
+
+
+netlifyAPIToken: {
+    type: "Netlify API Token",
+    pattern: XRegExp('^net_[A-Za-z0-9]{32}$'),
+    description: "Matches Netlify API tokens prefixed with 'net_'.",
+    tags: ["Netlify", "API Token"]
+},
+
+
+nexmoAPIKey: {
+    type: "Nexmo API Key",
+    pattern: XRegExp('^[0-9a-zA-Z]{32}$'),
+    description: "Matches 32-character Nexmo API keys.",
+    tags: ["Nexmo", "API Key"]
+},
+
+
+ninjaFormsAPIKey: {
+    type: "Ninja Forms API Key",
+    pattern: XRegExp('^nf_[A-Za-z0-9]{20}$'),
+    description: "Matches Ninja Forms API keys prefixed with 'nf_'.",
+    tags: ["Ninja Forms", "API Key"]
+},
+
+
+notionAPIKey: {
+    type: "Notion API Key",
+    pattern: XRegExp('^secret_[0-9a-zA-Z]{43}$'),
+    description: "Matches Notion API keys prefixed with 'secret_'.",
+    tags: ["Notion", "API Key"]
+},
+
+
+oktaAPIToken: {
+    type: "Okta API Token",
+    pattern: XRegExp('^[0-9a-zA-Z]{40}$'),
+    description: "Matches 40-character Okta API tokens.",
+    tags: ["Okta", "API Token"]
+},
+
+
+openAIUserAPIKey: {
+    type: "OpenAI User API Key",
+    pattern: XRegExp('\\bsk-[a-zA-Z0-9]{48}\\b'),
+    description: "Matches OpenAI API keys prefixed with 'sk-'.",
+    tags: ["OpenAI", "User API Key"]
+},
+
+
+pagerDutyAPIToken: {
+    type: "PagerDuty API Token",
+    pattern: XRegExp('^pdt_[A-Za-z0-9]{32}$'),
+    description: "Matches PagerDuty API tokens prefixed with 'pdt_'.",
+    tags: ["PagerDuty", "API Token"]
+},
+
+
+paypalAccessToken: {
+    type: "Paypal Access Token",
+    pattern: XRegExp('^[0-9a-f]{32}\\.[0-9a-f]{32}$'),
+    description: "Matches Paypal access tokens in specific format.",
+    tags: ["Paypal", "Access Token"]
+},
+
+
+pinterestAccessToken: {
+    type: "Pinterest Access Token",
+    pattern: XRegExp('^pi_[A-Za-z0-9]{32}$'),
+    description: "Matches Pinterest access tokens prefixed with 'pi_'.",
+    tags: ["Pinterest", "Access Token"]
+},
+
+
+pipedriveAPIKey: {
+    type: "Pipedrive API Key",
+    pattern: XRegExp('^pd_[A-Za-z0-9]{40}$'),
+    description: "Matches Pipedrive API keys prefixed with 'pd_'.",
+    tags: ["Pipedrive", "API Key"]
+},
+
+
+procoreAPIKey: {
+    type: "Procore API Key",
+    pattern: XRegExp('^pcore_[A-Za-z0-9]{40}$'),
+    description: "Matches Procore API keys prefixed with 'pcore_'.",
+    tags: ["Procore", "API Key"]
+},
+
+quickbooksAPIKey: {
+    type: "QuickBooks API Key",
+    pattern: XRegExp('^qb_[A-Za-z0-9]{32}$'),
+    description: "Matches QuickBooks API keys prefixed with 'qb_'.",
+    tags: ["QuickBooks", "API Key"]
+},
+
+
+quipAPIKey: {
+    type: "Quip API Key",
+    pattern: XRegExp('^quip-[A-Za-z0-9]{32}$'),
+    description: "Matches Quip API keys prefixed with 'quip-'.",
+    tags: ["Quip", "API Key"]
+},
+
+
+salesforceAccessToken: {
+    type: "Salesforce Access Token",
+    pattern: XRegExp('^00D[a-zA-Z0-9]{15,18}$'),
+    description: "Matches Salesforce access tokens prefixed with '00D'.",
+    tags: ["Salesforce", "Access Token"]
+},
+
+
+sendgridAPIKey: {
+    type: "SendGrid API Key",
+    pattern: XRegExp('^SG\\.[A-Za-z0-9_-]{22}\\.[A-Za-z0-9_-]{43}$'),
+    description: "Matches SendGrid API keys prefixed with 'SG.'.",
+    tags: ["SendGrid", "API Key"]
+},
+
+
+shopifyAccessToken: {
+    type: "Shopify Access Token",
+    pattern: XRegExp('^shpat_[A-Za-z0-9]{32}$'),
+    description: "Matches Shopify access tokens prefixed with 'shpat_'.",
+    tags: ["Shopify", "Access Token"]
+},
+
+
+slackAPIToken: {
+    type: "Slack API Token",
+    pattern: XRegExp('^xox[baprs]-[A-Za-z0-9-]{10,48}$'),
+    description: "Matches Slack API tokens prefixed with 'xox[baprs]-'.",
+    tags: ["Slack", "API Token"]
+},
+
+
+spotifyAccessToken: {
+    type: "Spotify Access Token",
+    pattern: XRegExp('^[A-Za-z0-9]{80}$'),
+    description: "Matches 80-character Spotify access tokens.",
+    tags: ["Spotify", "Access Token"]
+},
+
+
+squareAccessToken: {
+    type: "Square Access Token",
+    pattern: XRegExp('^sq0atp-[A-Za-z0-9]{22}$'),
+    description: "Matches Square access tokens prefixed with 'sq0atp-'.",
+    tags: ["Square", "Access Token"]
+},
+
+
+stripeAPIKey: {
+    type: "Stripe API Key",
+    pattern: XRegExp('\\bsk_live_[A-Za-z0-9]{24,32}\\b'),
+    description: "Matches Stripe API keys prefixed with 'sk_live_'.",
+    tags: ["Stripe", "API Key"]
+},
+
+
+tableauAPIKey: {
+    type: "Tableau API Key",
+    pattern: XRegExp('^tab_[A-Za-z0-9]{32}$'),
+    description: "Matches Tableau API keys prefixed with 'tab_'.",
+    tags: ["Tableau", "API Key"]
+},
+
+
+telegramBotToken: {
+    type: "Telegram Bot Token",
+    pattern: XRegExp('^[0-9]+:[A-Za-z0-9_-]{35}$'),
+    description: "Matches Telegram bot tokens in the format 'digits:token'.",
+    tags: ["Telegram", "Bot Token"]
+},
+
+
+twilioAPIKey: {
+    type: "Twilio API Key",
+    pattern: XRegExp('^SK[A-Za-z0-9]{32}$'),
+    description: "Matches Twilio API keys prefixed with 'SK'.",
+    tags: ["Twilio", "API Key"]
+},
+
+
+twitterBearerToken: {
+    type: "Twitter Bearer Token",
+    pattern: XRegExp('^AAAAAAAA[A-Za-z0-9-_]{80}$'),
+    description: "Matches Twitter Bearer tokens prefixed with 'AAAAAAAA'.",
+    tags: ["Twitter", "Bearer Token"]
+},
+
+
+typeformAPIKey: {
+    type: "Typeform API Key",
+    pattern: XRegExp('^tfp_[A-Za-z0-9]{40}$'),
+    description: "Matches Typeform API keys prefixed with 'tfp_'.",
+    tags: ["Typeform", "API Key"]
+},
+
+
+vimeoAccessToken: {
+    type: "Vimeo Access Token",
+    pattern: XRegExp('^vimeo-[A-Za-z0-9]{32}$'),
+    description: "Matches Vimeo access tokens prefixed with 'vimeo-'.",
+    tags: ["Vimeo", "Access Token"]
+},
+
+
+vonageAPIKey: {
+    type: "Vonage API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches 32-character Vonage API keys.",
+    tags: ["Vonage", "API Key"]
+},
+
+
+whatsappAccessToken: {
+    type: "WhatsApp Access Token",
+    pattern: XRegExp('^EAAG[A-Za-z0-9]{32,64}$'),
+    description: "Matches WhatsApp access tokens prefixed with 'EAAG'.",
+    tags: ["WhatsApp", "Access Token"]
+},
+
+
+woocommerceAPIKey: {
+    type: "WooCommerce API Key",
+    pattern: XRegExp('^(ck|cs)_[A-Za-z0-9]{32}$'),
+    description: "Matches WooCommerce API keys prefixed with 'ck_' or 'cs_'.",
+    tags: ["WooCommerce", "API Key"]
+},
+
+
+wordpressAPIKey: {
+    type: "Wordpress.com API Key",
+    pattern: XRegExp('^wp_[A-Za-z0-9]{40}$'),
+    description: "Matches Wordpress.com API keys prefixed with 'wp_'.",
+    tags: ["Wordpress.com", "API Key"]
+},
+
+
+zendeskAPIKey: {
+    type: "Zendesk API Key",
+    pattern: XRegExp('^ZDAPI[A-Za-z0-9]{24}$'),
+    description: "Matches Zendesk API keys prefixed with 'ZDAPI'.",
+    tags: ["Zendesk", "API Key"]
+},
+
+
+zoomAPIKey: {
+    type: "Zoom API Key",
+    pattern: XRegExp('^ZOOM[A-Za-z0-9]{20,32}$'),
+    description: "Matches Zoom API keys prefixed with 'ZOOM'.",
+    tags: ["Zoom", "API Key"]
+},
+
+zohoAPIKey: {
+    type: "Zoho API Key",
+    pattern: XRegExp('^zoho_[A-Za-z0-9]{32}$'),
+    description: "Matches Zoho API keys prefixed with 'zoho_'.",
+    tags: ["Zoho", "API Key"]
+},
+
+
+yandexAPIKey: {
+    type: "Yandex API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches 32-character Yandex API keys.",
+    tags: ["Yandex", "API Key"]
+},
+
+
+paypalClientID: {
+    type: "PayPal Client ID",
+    pattern: XRegExp('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'),
+    description: "Matches PayPal Client IDs in UUID format.",
+    tags: ["PayPal", "Client ID"]
+},
+
+
+digitalOceanAPIKey: {
+    type: "DigitalOcean API Key",
+    pattern: XRegExp('^do_[A-Za-z0-9]{64}$'),
+    description: "Matches DigitalOcean API keys prefixed with 'do_'.",
+    tags: ["DigitalOcean", "API Key"]
+},
+
+
+hubSpotPrivateAppKey: {
+    type: "HubSpot Private App Key",
+    pattern: XRegExp('^pat-[A-Za-z0-9]{40}$'),
+    description: "Matches HubSpot private app keys prefixed with 'pat-'.",
+    tags: ["HubSpot", "Private App Key"]
+},
+
+
+openWeatherMapAPIKey: {
+    type: "OpenWeatherMap API Key",
+    pattern: XRegExp('^[A-Za-z0-9]{32}$'),
+    description: "Matches 32-character OpenWeatherMap API keys.",
+    tags: ["OpenWeatherMap", "API Key"]
+},
+
+
+nexmoApplicationKey: {
+    type: "Nexmo Application Key",
+    pattern: XRegExp('^NEXMO_[A-Za-z0-9]{32}$'),
+    description: "Matches Nexmo application keys prefixed with 'NEXMO_'.",
+    tags: ["Nexmo", "Application Key"]
+},
+
+
+bitlyAPIKey: {
+    type: "Bitly API Key",
+    pattern: XRegExp('^bt_[A-Za-z0-9]{20}$'),
+    description: "Matches Bitly API keys prefixed with 'bt_'.",
+    tags: ["Bitly", "API Key"]
+},
+
+
+mapboxAPIKey: {
+    type: "Mapbox API Key",
+    pattern: XRegExp('^pk\\.[A-Za-z0-9]{60}$'),
+    description: "Matches Mapbox API keys prefixed with 'pk.'.",
+    tags: ["Mapbox", "API Key"]
+},
+
+
+contentstackAPIKey: {
+    type: "Contentstack API Key",
+    pattern: XRegExp('^cs_[A-Za-z0-9]{20}$'),
+    description: "Matches Contentstack API keys prefixed with 'cs_'.",
+    tags: ["Contentstack", "API Key"]
+},
+
+
+plivoAPIKey: {
+    type: "Plivo API Key",
+    pattern: XRegExp('^plivo_[A-Za-z0-9]{40}$'),
+    description: "Matches Plivo API keys prefixed with 'plivo_'.",
+    tags: ["Plivo", "API Key"]
+},
+
+
+freshserviceToken: {
+    type: "Freshservice Token",
+    pattern: XRegExp('^fs_[A-Za-z0-9]{32}$'),
+    description: "Matches Freshservice tokens prefixed with 'fs_'.",
+    tags: ["Freshservice", "Token"]
+},
+
+
+vimeoAccessToken: {
+    type: "Vimeo Access Token",
+    pattern: XRegExp('^vimeo-[A-Za-z0-9]{40}$'),
+    description: "Matches Vimeo access tokens prefixed with 'vimeo-'.",
+    tags: ["Vimeo", "Access Token"]
+},
+
+
+baseCRMToken: {
+    type: "Base CRM Token",
+    pattern: XRegExp('^[A-Za-z0-9]{40}$'),
+    description: "Matches 40-character Base CRM tokens.",
+    tags: ["Base CRM", "Access Token"]
+},
+
+
+serviceNowAPIKey: {
+    type: "ServiceNow API Key",
+    pattern: XRegExp('^sn_[A-Za-z0-9]{32}$'),
+    description: "Matches ServiceNow API keys prefixed with 'sn_'.",
+    tags: ["ServiceNow", "API Key"]
+},
+
+
+mailgunAPIKey: {
+    type: "Mailgun API Key",
+    pattern: XRegExp('^key-[A-Za-z0-9]{32}$'),
+    description: "Matches Mailgun API keys prefixed with 'key-'.",
+    tags: ["Mailgun", "API Key"]
+},
+
+
+intercomAPIKey: {
+    type: "Intercom API Key",
+    pattern: XRegExp('^ic_[A-Za-z0-9]{32}$'),
+    description: "Matches Intercom API keys prefixed with 'ic_'.",
+    tags: ["Intercom", "API Key"]
+},
+
+
+twilioSID: {
+    type: "Twilio SID",
+    pattern: XRegExp('^AC[A-Za-z0-9]{32}$'),
+    description: "Matches Twilio SIDs prefixed with 'AC'.",
+    tags: ["Twilio", "SID"]
+},
+
+
+azureStorageAccountKey: {
+    type: "Azure Storage Account Key",
+    pattern: XRegExp('^[A-Za-z0-9+/=]{88}$'),
+    description: "Matches 88-character Azure Storage Account keys in base64 format.",
+    tags: ["Azure", "Storage Account Key"]
+},
+
+
+ibmCloudIAMToken: {
+    type: "IBM Cloud IAM Token",
+    pattern: XRegExp('^icp4d-[A-Za-z0-9]{32}$'),
+    description: "Matches IBM Cloud IAM tokens prefixed with 'icp4d-'.",
+    tags: ["IBM Cloud", "IAM Token"]
+},
+
+
+dropboxSecretKey: {
+    type: "Dropbox Secret Key",
+    pattern: XRegExp('^[A-Za-z0-9]{64}$'),
+    description: "Matches 64-character Dropbox secret keys.",
+    tags: ["Dropbox", "Secret Key"]
+},
+
+
+googleServiceAccountKey: {
+    type: "Google Service Account Key",
+    pattern: XRegExp('"type":\\s*"service_account"'),
+    description: "Matches Google Service Account Keys in JSON format.",
+    tags: ["Google", "Service Account Key"]
+},
+
+
+firebaseSecret: {
+    type: "Firebase Secret",
+    pattern: XRegExp('^fbase_[A-Za-z0-9]{40}$'),
+    description: "Matches Firebase secrets prefixed with 'fbase_'.",
+    tags: ["Firebase", "Secret"]
+	
+	}
+};
+
+
+	
+
+
diff --git a/Authenticator/repo/public/ptr/cryptoPatterns.js b/Authenticator/repo/public/ptr/cryptoPatterns.js
new file mode 100644
index 000000000..5dbc85921
--- /dev/null
+++ b/Authenticator/repo/public/ptr/cryptoPatterns.js
@@ -0,0 +1,118 @@
+const bip39WordList = "(abandon|ability|able|about|above|absent|absorb|abstract|absurd|abuse|access|accident|account|accuse|achieve|acid|acoustic|acquire|across|act|action|actor|actress|actual|adapt|add|addict|address|adjust|admit|adult|advance|advice|aerobic|affair|afford|afraid|again|age|agent|agree|ahead|aim|air|airport|aisle|alarm|album|alcohol|alert|alien|all|alley|allow|almost|alone|alpha|already|also|alter|always|amateur|amazing|among|amount|amused|analyst|anchor|ancient|anger|angle|angry|animal|ankle|announce|annual|another|answer|antenna|antique|anxiety|any|apart|apology|appear|apple|approve|april|arch|arctic|area|arena|argue|arm|armed|armor|army|around|arrange|arrest|arrive|arrow|art|artefact|artist|artwork|ask|aspect|assault|asset|assist|assume|asthma|athlete|atom|attack|attend|attitude|attract|auction|audit|august|aunt|author|auto|autumn|average|avocado|avoid|awake|aware|away|awesome|awful|awkward|axis|baby|bachelor|bacon|badge|bag|balance|balcony|ball|bamboo|banana|banner|bar|barely|bargain|barrel|base|basic|basket|battle|beach|bean|beauty|because|become|beef|before|begin|behave|behind|believe|below|belt|bench|benefit|best|betray|better|between|beyond|bicycle|bid|bike|bind|biology|bird|birth|bitter|black|blade|blame|blanket|blast|bleak|bless|blind|blood|blossom|blouse|blue|blur|blush|board|boat|body|boil|bomb|bone|bonus|book|boost|border|boring|borrow|boss|bottom|bounce|box|boy|bracket|brain|brand|brass|brave|bread|breeze|brick|bridge|brief|bright|bring|brisk|broccoli|broken|bronze|broom|brother|brown|brush|bubble|buddy|budget|buffalo|build|bulb|bulk|bullet|bundle|bunker|burden|burger|burst|bus|business|busy|butter|buyer|buzz|cabbage|cabin|cable|cactus|cage|cake|call|calm|camera|camp|can|canal|cancel|candy|cannon|canoe|canvas|canyon|capable|capital|captain|car|carbon|card|cargo|carpet|carry|cart|case|cash|casino|castle|casual|cat|catalog|catch|category|cattle|caught|cause|caution|cave|ceiling|celery|cement|census|century|cereal|certain|chair|chalk|champion|change|chaos|chapter|charge|chase|chat|cheap|check|cheese|chef|cherry|chest|chicken|chief|child|chimney|choice|choose|chronic|chuckle|chunk|churn|cigar|cinnamon|circle|citizen|city|civil|claim|clap|clarify|claw|clay|clean|clerk|clever|click|client|cliff|climb|clinic|clip|clock|clog|close|cloth|cloud|clown|club|clump|cluster|clutch|coach|coast|coconut|code|coffee|coil|coin|collect|color|column|combine|come|comfort|comic|common|company|concert|conduct|confirm|congress|connect|consider|control|convince|cook|cool|copper|copy|coral|core|corn|correct|cost|cotton|couch|country|couple|course|cousin|cover|coyote|crack|cradle|craft|cram|crane|crash|crater|crawl|crazy|cream|credit|creek|crew|cricket|crime|crisp|critic|crop|cross|crouch|crowd|crucial|cruel|cruise|crumble|crunch|crush|cry|crystal|cube|culture|cup|cupboard|curious|current|curtain|curve|cushion|custom|cute|cycle|dad|damage|damp|dance|danger|daring|dash|daughter|dawn|day|deal|debate|debris|decade|december|decide|decline|decorate|decrease|deer|defense|define|defy|degree|delay|deliver|demand|demise|denial|dentist|deny|depart|depend|deposit|depth|deputy|derive|describe|desert|design|desk|despair|destroy|detail|detect|develop|device|devote|diagram|dial|diamond|diary|dice|diesel|diet|differ|digital|dignity|dilemma|dinner|dinosaur|direct|dirt|disagree|discover|disease|dish|dismiss|disorder|display|distance|divert|divide|divorce|dizzy|doctor|document|dog|doll|dolphin|domain|donate|donkey|donor|door|dose|double|dove|draft|dragon|drama|drastic|draw|dream|dress|drift|drill|drink|drip|drive|drop|drum|dry|duck|dumb|dune|during|dust|dutch|duty|dwarf|dynamic|eager|eagle|early|earn|earth|easily|east|easy|echo|ecology|economy|edge|edit|educate|effort|egg|eight|either|elbow|elder|electric|elegant|element|elevator|elite|else|embark|embody|embrace|emerge|emotion|employ|empower|empty|enable|enact|end|endless|endorse|enemy|energy|enforce|engage|engine|enhance|enjoy|enlist|enough|enrich|enroll|ensure|enter|entire|entry|envelope|episode|equal|equip|era|erase|erode|erosion|error|erupt|escape|essay|essence|estate|eternal|ethics|evidence|evil|evoke|evolve|exact|example|excess|exchange|excite|exclude|excuse|execute|exercise|exhaust|exhibit|exile|exist|exit|exotic|expand|expect|expire|explain|expose|express|extend|extra|eye|eyebrow|fabric|face|faculty|fade|faint|faith|fall|false|fame|family|famous|fan|fancy|fantasy|farm|fashion|fat|fatal|father|fatigue|fault|favorite|feature|february|federal|fee|feed|feel|female|fence|festival|fetch|fever|few|fiber|fiction|field|figure|file|film|filter|final|find|fine|finger|finish|fire|firm|first|fiscal|fish|fit|fitness|fix|flag|flame|flash|flat|flavor|flee|flight|flip|float|flock|floor|flower|fluid|flush|fly|foam|focus|fog|foil|fold|follow|food|foot|force|forest|forget|fork|fortune|forum|forward|fossil|foster|found|fox|fragile|frame|frequent|fresh|friend|fringe|frog|front|frost|frown|frozen|fruit|fuel|fun|funny|furnace|fury|future|gadget|gain|galaxy|gallery|game|gap|garage|garbage|garden|garlic|garment|gas|gasp|gate|gather|gauge|gaze|general|genius|genre|gentle|genuine|gesture|ghost|giant|gift|giggle|ginger|giraffe|girl|give|glad|glance|glare|glass|glide|glimpse|globe|gloom|glory|glove|glow|glue|goat|goddess|gold|good|goose|gorilla|gospel|gossip|govern|gown|grab|grace|grain|grant|grape|grass|gravity|great|green|grid|grief|grit|grocery|group|grow|grunt|guard|guess|guide|guilt|guitar|gun|gym|habit|hair|half|hammer|hamster|hand|happy|harbor|hard|harsh|harvest|hat|have|hawk|hazard|head|health|heart|heavy|hedgehog|height|hello|helmet|help|hen|hero|hidden|high|hill|hint|hip|hire|history|hobby|hockey|hold|hole|holiday|hollow|home|honey|hood|hope|horn|horror|horse|hospital|host|hotel|hour|hover|hub|huge|human|humble|humor|hundred|hungry|hunt|hurdle|hurry|hurt|husband|hybrid|ice|icon|idea|identify|idle|ignore|ill|illegal|illness|image|imitate|immense|immune|impact|impose|improve|impulse|inch|include|income|increase|index|indicate|indoor|industry|infant|inflict|inform|inhale|inherit|initial|inject|injury|inmate|inner|innocent|input|inquiry|insane|insect|inside|inspire|install|intact|interest|into|invest|invite|involve|iron|island|isolate|issue|item|ivory|jacket|jaguar|jar|jazz|jealous|jeans|jelly|jewel|job|join|joke|journey|joy|judge|juice|jump|jungle|junior|junk|just|kangaroo|keen|keep|ketchup|key|kick|kid|kidney|kind|kingdom|kiss|kit|kitchen|kite|kitten|kiwi|knee|knife|knock|know|lab|label|labor|ladder|lady|lake|lamp|language|laptop|large|later|latin|laugh|laundry|lava|law|lawn|lawsuit|layer|lazy|leader|leaf|learn|leave|lecture|left|leg|legal|legend|leisure|lemon|lend|length|lens|leopard|lesson|letter|level|liar|liberty|library|license|life|lift|light|like|limb|limit|link|lion|liquid|list|little|live|lizard|load|loan|lobster|local|lock|logic|lonely|long|loop|lottery|loud|lounge|love|loyal|lucky|luggage|lumber|lunar|lunch|luxury|lyrics|machine|mad|magic|magnet|maid|mail|main|major|make|mammal|man|manage|mandate|mango|mansion|manual|maple|marble|march|margin|marine|market|marriage|mask|mass|master|match|material|math|matrix|matter|maximum|maze|meadow|mean|measure|meat|mechanic|medal|media|melody|melt|member|memory|mention|menu|mercy|merge|merit|merry|mesh|message|metal|method|middle|midnight|milk|million|mimic|mind|minimum|minor|minute|miracle|mirror|misery|miss|mistake|mix|mixed|mixture|mobile|model|modify|mom|moment|monitor|monkey|monster|month|moon|moral|more|morning|mosquito|mother|motion|motor|mountain|mouse|move|movie|much|muffin|mule|multiply|muscle|museum|mushroom|music|must|mutual|myself|mystery|myth|naive|name|napkin|narrow|nasty|nation|nature|near|neck|need|negative|neglect|neither|nephew|nerve|nest|net|network|neutral|never|news|next|nice|night|noble|noise|nominee|noodle|normal|north|nose|notable|note|nothing|notice|novel|now|nuclear|number|nurse|nut|oak|obey|object|oblige|obscure|observe|obtain|obvious|occur|ocean|october|odor|off|offer|office|often|oil|okay|old|olive|olympic|omit|once|one|onion|online|only|open|opera|opinion|oppose|option|orange|orbit|orchard|order|ordinary|organ|orient|original|orphan|ostrich|other|outdoor|outer|output|outside|oval|oven|over|own|owner|oxygen|oyster|ozone|pact|paddle|page|pair|palace|palm|panda|panel|panic|panther|paper|parade|parent|park|parrot|party|pass|patch|path|patient|patrol|pattern|pause|pave|payment|peace|peanut|pear|peasant|pelican|pen|penalty|pencil|people|pepper|perfect|permit|person|pet|phone|photo|phrase|physical|piano|picnic|picture|piece|pig|pigeon|pill|pilot|pink|pioneer|pipe|pistol|pitch|pizza|place|planet|plastic|plate|play|please|pledge|pluck|plug|plunge|poem|poet|point|polar|pole|police|pond|pony|pool|popular|portion|position|possible|post|potato|pottery|poverty|powder|power|practice|praise|predict|prefer|prepare|present|pretty|prevent|price|pride|primary|print|priority|prison|private|prize|problem|process|produce|profit|program|project|promote|proof|property|prosper|protect|proud|provide|public|pudding|pull|pulp|pulse|pumpkin|punch|pupil|puppy|purchase|purity|purpose|purse|push|put|puzzle|pyramid|quality|quantum|quarter|question|quick|quit|quiz|quote|rabbit|raccoon|race|rack|radar|radio|rail|rain|raise|rally|ramp|ranch|random|range|rapid|rare|rate|rather|raven|raw|razor|ready|real|reason|rebel|rebuild|recall|receive|recipe|record|recycle|reduce|reflect|reform|refuse|region|regret|regular|reject|relax|release|relief|rely|remain|remember|remind|remove|render|renew|rent|reopen|repair|repeat|replace|report|require|rescue|resemble|resist|resource|response|result|retire|retreat|return|reunion|reveal|review|reward|rhythm|rib|ribbon|rice|rich|ride|ridge|rifle|right|rigid|ring|riot|ripple|risk|ritual|rival|river|road|roast|robot|robust|rocket|romance|roof|rookie|room|rose|rotate|rough|round|route|royal|rubber|rude|rug|rule|run|runway|rural|sad|saddle|sadness|safe|sail|salad|salmon|salon|salt|salute|same|sample|sand|satisfy|satoshi|sauce|sausage|save|say|scale|scan|scare|scatter|scene|scheme|school|science|scissors|scorpion|scout|scrap|screen|script|scrub|sea|search|season|seat|second|secret|section|security|seed|seek|segment|select|sell|seminar|senior|sense|sentence|series|service|session|settle|setup|seven|shadow|shaft|shallow|share|shed|shell|sheriff|shield|shift|shine|ship|shiver|shock|shoe|shoot|shop|short|shoulder|shove|shrimp|shrug|shuffle|shy|sibling|sick|side|siege|sight|sign|silent|silk|silly|silver|similar|simple|since|sing|siren|sister|situate|six|size|skate|sketch|ski|skill|skin|skirt|skull|slab|slam|sleep|slender|slice|slide|slight|slim|slogan|slot|slow|slush|small|smart|smile|smoke|smooth|snack|snake|snap|sniff|snow|soap|soccer|social|sock|soda|soft|solar|soldier|solid|solution|solve|someone|song|soon|sorry|sort|soul|sound|soup|source|south|space|spare|spatial|spawn|speak|special|speed|spell|spend|sphere|spice|spider|spike|spin|spirit|split|spoil|sponsor|spoon|sport|spot|spray|spread|spring|spy|square|squeeze|squirrel|stable|stadium|staff|stage|stairs|stamp|stand|start|state|stay|steak|steel|stem|step|stereo|stick|still|sting|stock|stomach|stone|stool|story|stove|strategy|street|strike|strong|struggle|student|stuff|stumble|style|subject|submit|subway|success|such|sudden|suffer|sugar|suggest|suit|summer|sun|sunny|sunset|super|supply|supreme|sure|surface|surge|surprise|surround|survey|suspect|sustain|swallow|swamp|swap|swarm|swear|sweet|swift|swim|swing|switch|sword|symbol|symptom|syrup|system|table|tackle|tag|tail|talent|talk|tank|tape|target|task|taste|tattoo|taxi|teach|team|tell|ten|tenant|tennis|tent|term|test|text|thank|that|theme|then|theory|there|they|thing|this|thought|three|thrive|throw|thumb|thunder|ticket|tide|tiger|tilt|timber|time|tiny|tip|tired|tissue|title|toast|tobacco|today|toddler|toe|together|toilet|token|tomato|tomorrow|tone|tongue|tonight|tool|tooth|top|topic|topple|torch|tornado|tortoise|toss|total|tourist|toward|tower|town|toy|track|trade|traffic|tragic|train|transfer|trap|trash|travel|tray|treat|tree|trend|trial|tribe|trick|trigger|trim|trip|trophy|trouble|truck|true|truly|trumpet|trust|truth|try|tube|tuition|tumble|tuna|tunnel|turkey|turn|turtle|twelve|twenty|twice|twin|twist|two|type|typical|ugly|umbrella|unable|unaware|uncle|uncover|under|undo|unfair|unfold|unhappy|uniform|unique|unit|universe|unknown|unlock|until|unusual|unveil|update|upgrade|uphold|upon|upper|upset|urban|urge|usage|use|used|useful|useless|usual|utility|vacant|vacuum|vague|valid|valley|valve|van|vanish|vapor|various|vast|vault|vehicle|velvet|vendor|venture|venue|verb|verify|version|very|vessel|veteran|viable|vibrant|vicious|victory|video|view|village|vintage|violin|virtual|virus|visa|visit|visual|vital|vivid|vocal|voice|void|volcano|volume|vote|voyage|wage|wagon|wait|walk|wall|walnut|want|warfare|warm|warrior|wash|wasp|waste|water|wave|way|wealth|weapon|wear|weasel|weather|web|wedding|weekend|weird|welcome|west|wet|whale|what|wheat|wheel|when|where|whip|whisper|wide|width|wife|wild|will|win|window|wine|wing|wink|winner|winter|wire|wisdom|wise|wish|witness|wolf|woman|wonder|wood|wool|word|work|world|worry|worth|wrap|wreck|wrestle|wrist|write|wrong|yard|year|yellow|you|young|youth|zebra|zero|zone|zoo)";
+
+const cryptoPatterns = {
+
+   bitcoin: {
+        type: "Bitcoin (BTC)",
+        pattern: XRegExp('\\b(?:bitcoin[:\\s]*|btc[:\\s]*|address[:\\s]*|wallet[:\\s]*)?(bc1[a-z0-9]{38,41}|[13][a-km-zA-HJ-NP-Z1-9]{25,33})\\b', 'i'),
+        description: "Matches Bitcoin addresses, including 'bc1', '1', and '3' formats.",
+        tags: ["Crypto", "Bitcoin", "Address"]
+    },
+    cardano: {
+        type: "Cardano (ADA)",
+        pattern: XRegExp('\\b(?:ada[:\\s]*|cardano[:\\s]*|address[:\\s]*|wallet[:\\s]*)?(addr1[a-z0-9]{54,100}|Ae2[a-zA-Z0-9]{57})\\b', 'i'),
+        description: "Matches Cardano addresses starting with 'addr1' or 'Ae2'.",
+        tags: ["Crypto", "Cardano", "Address"]
+    },
+    ethereum: {
+        type: "Ethereum (ETH)",
+        pattern: XRegExp('\\b(?:ethereum[:\\s]*|eth[:\\s]*|address[:\\s]*|wallet[:\\s]*|erc20[:\\s]*)?0x[a-fA-F0-9]{40}\\b(?![a-fA-F0-9])', 'i'),
+        description: "Matches Ethereum addresses, starting with '0x'.",
+        tags: ["Crypto", "Ethereum", "Address"]
+    },
+    xrp: {
+        type: "XRP (Ripple)",
+        pattern: XRegExp('\\b(?:xrp[:\\s]*|ripple[:\\s]*|address[:\\s]*|wallet[:\\s]*)?r[r4-9][a-hj-np-zA-HJ-NP-Z0-9]{24,33}\\b', 'i'),
+        description: "Matches XRP (Ripple) addresses starting with 'r'.",
+        tags: ["Crypto", "XRP", "Address"]
+    },
+    solana: {
+        type: "Solana (SOL)",
+        pattern: XRegExp('\\b(?:sol[:\\s]*|solana[:\\s]*|address[:\\s]*|wallet[:\\s]*)?[1-9A-HJ-NP-Za-km-z]{43,44}\\b', 'i'),
+        description: "Matches Solana addresses with 43-44 characters.",
+        tags: ["Crypto", "Solana", "Address"]
+    },
+    dogecoin: {
+        type: "Dogecoin (DOGE)",
+        pattern: XRegExp('\\b(?:doge[:\\s]*|dogecoin[:\\s]*|address[:\\s]*|wallet[:\\s]*)?(D[a-km-zA-HJ-NP-Z1-9]{33})\\b', 'i'),
+        description: "Matches Dogecoin addresses starting with 'D'.",
+        tags: ["Crypto", "Dogecoin", "Address"]
+    },
+    polkadot: {
+        type: "Polkadot (DOT)",
+        pattern: XRegExp('\\b(?:dot[:\\s]*|polkadot[:\\s]*|address[:\\s]*|wallet[:\\s]*)?(1[46]?[a-km-zA-HJ-NP-Z1-9]{46})\\b', 'i'),
+        description: "Matches Polkadot addresses with specific format.",
+        tags: ["Crypto", "Polkadot", "Address"]
+    },
+    avalanche: {
+        type: "Avalanche (AVAX)",
+        pattern: XRegExp('\\b(?:avax[:\\s]*|avalanche[:\\s]*|address[:\\s]*|wallet[:\\s]*)?(X|P|C)-avax1[a-z0-9]{38,57}\\b', 'i'),
+        description: "Matches Avalanche addresses prefixed with 'X-', 'P-', or 'C-avax1'.",
+        tags: ["Crypto", "Avalanche", "Address"]
+    },
+    litecoin: {
+        type: "Litecoin (LTC)",
+        pattern: XRegExp('\\b(?:ltc[:\\s]*|litecoin[:\\s]*|address[:\\s]*|wallet[:\\s]*)?(L[a-km-zA-HJ-NP-Z1-9]{25,33}|M[a-km-zA-HJ-NP-Z1-9]{25,33}|ltc1[a-z0-9]{38,59})\\b', 'i'),
+        description: "Matches Litecoin addresses, including 'L', 'M', and 'ltc1' formats.",
+        tags: ["Crypto", "Litecoin", "Address"]
+    },
+    stellar: {
+        type: "Stellar (XLM)",
+        pattern: XRegExp('\\b(?:xlm[:\\s]*|stellar[:\\s]*|address[:\\s]*|wallet[:\\s]*)?G[A-Z2-7]{55}\\b(?![A-Z2-7])', 'i'),
+        description: "Matches Stellar addresses starting with 'G'.",
+        tags: ["Crypto", "Stellar", "Address"]
+    },
+    bitcoinPrivateKey: {
+        type: "Bitcoin Private Key (WIF)",
+        pattern: XRegExp('\\b(?:bitcoin[:\\s]*|btc[:\\s]*|private[-\\s]*key[:\\s]*)?(5[HJK][1-9A-HJ-NP-Za-km-z]{49}|[LK][1-9A-HJ-NP-Za-km-z]{51})\\b', 'i'),
+        description: "Matches Bitcoin private keys in Wallet Import Format (WIF).",
+        tags: ["Crypto", "Bitcoin", "Private Key"]
+    },
+    ethereumPrivateKey: {
+        type: "Ethereum Private Key",
+        pattern: XRegExp('\\b(?:ethereum[:\\s]*|eth[:\\s]*|private[-\\s]*key[:\\s]*)?0x[a-fA-F0-9]{64}\\b', 'i'),
+        description: "Matches 64-character Ethereum private keys prefixed with '0x'.",
+        tags: ["Crypto", "Ethereum", "Private Key"]
+    },
+    rippleSecretKey: {
+        type: "Ripple Secret Key",
+        pattern: XRegExp('\\b(?:xrp[:\\s]*|ripple[:\\s]*|secret[-\\s]*key[:\\s]*)?s[a-zA-HJ-NP-Z0-9]{28,34}\\b', 'i'),
+        description: "Matches Ripple (XRP) secret keys starting with 's'.",
+        tags: ["Crypto", "XRP", "Secret Key"]
+    },
+    solanaPrivateKey: {
+        type: "Solana Private Key",
+        pattern: XRegExp('\\b(?:solana[:\\s]*|sol[:\\s]*|private[-\\s]*key[:\\s]*)?[1-9A-HJ-NP-Za-km-z]{88}\\b', 'i'),
+        description: "Matches 88-character Solana private keys.",
+        tags: ["Crypto", "Solana", "Private Key"]
+    },
+    stellarSecretKey: {
+        type: "Stellar Secret Key",
+        pattern: XRegExp('\\b(?:xlm[:\\s]*|stellar[:\\s]*|secret[-\\s]*key[:\\s]*)?S[A-Z2-7]{55}\\b', 'i'),
+        description: "Matches Stellar secret keys starting with 'S'.",
+        tags: ["Crypto", "Stellar", "Secret Key"]
+    },
+    twelveWordSeedPhrase: {
+        type: "12-Word Seed Phrase",
+        pattern: XRegExp(`(?:\\b${bip39WordList}\\b(?:\\s*\\b${bip39WordList}\\b){6})`, 'i'),
+        description: "Matches 12-word seed phrases using common BIP-39 word lists.",
+        tags: ["Crypto", "Seed Phrase", "12-Word"]
+    },
+    eighteenWordSeedPhrase: {
+        type: "18-Word Seed Phrase",
+        pattern: XRegExp(`(?:\\b${bip39WordList}\\b(?:\\s*\\b${bip39WordList}\\b){8})`, 'i'),
+        description: "Matches 18-word seed phrases using common BIP-39 word lists.",
+        tags: ["Crypto", "Seed Phrase", "18-Word"]
+    },
+    twentyFourWordSeedPhrase: {
+        type: "24-Word Seed Phrase",
+        pattern: XRegExp(`(?:\\b${bip39WordList}\\b(?:\\s*\\b${bip39WordList}\\b){12})`, 'i'),
+        description: "Matches 24-word seed phrases using common BIP-39 word lists.",
+        tags: ["Crypto", "Seed Phrase", "24-Word"]
+    }
+
+
+};
+
+
+
diff --git a/Authenticator/repo/public/ptr/cryptoPatterns_new.js b/Authenticator/repo/public/ptr/cryptoPatterns_new.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/Authenticator/repo/public/ptr/fiPatterns.js b/Authenticator/repo/public/ptr/fiPatterns.js
new file mode 100644
index 000000000..0de0f93bf
--- /dev/null
+++ b/Authenticator/repo/public/ptr/fiPatterns.js
@@ -0,0 +1,187 @@
+const fiPatterns = {
+
+    visaCardNumber: {
+        type: "Visa Card Number",
+        pattern: XRegExp('\\b4\\d{3}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b'),
+        description: "Matches 16-digit Visa card numbers starting with '4'.",
+        tags: ["PCI DSS", "Credit Card", "Visa"]
+    },
+    mastercardNumber: {
+        type: "Mastercard Number",
+        pattern: XRegExp('\\b(?:5[1-5]\\d{2}|2[2-7]\\d{2})[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b'),
+        description: "Matches Mastercard numbers starting with '51-55' or '22-27'.",
+        tags: ["PCI DSS", "Credit Card", "Mastercard"]
+    },
+    amexNumber: {
+        type: "American Express (AMEX) Number",
+        pattern: XRegExp('\\b3[47]\\d{2}[-\\s]?\\d{6}[-\\s]?\\d{5}\\b'),
+        description: "Matches 15-digit American Express card numbers starting with '34' or '37'.",
+        tags: ["PCI DSS", "Credit Card", "AMEX"]
+    },
+    discoverCardNumber: {
+        type: "Discover Card Number",
+        pattern: XRegExp('\\b6(?:011|5\\d{2}|4[4-9]\\d{2}|22[1-9]\\d{2}|2[2-9]\\d{2})[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b'),
+        description: "Matches Discover card numbers with various valid prefixes.",
+        tags: ["PCI DSS", "Credit Card", "Discover"]
+    },
+    jcbCardNumber: {
+        type: "JCB Card Number",
+        pattern: XRegExp('\\b35\\d{2}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b'),
+        description: "Matches JCB card numbers starting with '35'.",
+        tags: ["PCI DSS", "Credit Card", "JCB"]
+    },
+    dinersClubCardNumber: {
+        type: "Diners Club Card Number",
+        pattern: XRegExp('\\b3(?:0[0-5]\\d{2}|[68]\\d{2})[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b'),
+        description: "Matches Diners Club card numbers with valid prefixes.",
+        tags: ["PCI DSS", "Credit Card", "Diners Club"]
+    },
+    unionPayCardNumber: {
+        type: "UnionPay Card Number",
+        pattern: XRegExp('\\b62\\d{2}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{0,3}\\b'),
+        description: "Matches UnionPay card numbers starting with '62'.",
+        tags: ["PCI DSS", "Credit Card", "UnionPay"]
+    },
+    maestroCardNumber: {
+        type: "Maestro Card Number",
+        pattern: XRegExp('\\b(?:5[06-9]\\d{2}|6\\d{3})[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{0,3}\\b'),
+        description: "Matches Maestro card numbers with specific prefixes.",
+        tags: ["PCI DSS", "Credit Card", "Maestro"]
+    },
+    cvvCode: {
+        type: "Card Verification Value (CVV/CVC)",
+        pattern: XRegExp('\\b(?:cvv|cvc|card security code|card verification value)\\s*[:\\s]?\\s*\\d{3,4}\\b', 'i'),
+        description: "Matches 3-4 digit CVV/CVC codes labeled appropriately.",
+        tags: ["PCI DSS", "Credit Card", "Security Code"]
+    },
+    expirationDate: {
+        type: "Expiration Date (MM/YY or MM/YYYY)",
+        pattern: XRegExp('\\b(?:exp|expiry|expires|valid thru|valid until|expiration)\\s*[:\\s]?\\s*(0[1-9]|1[0-2])\\/(2[0-9]{2}|2[0-9]{3})\\b', 'i'),
+        description: "Matches expiration dates in MM/YY or MM/YYYY format.",
+        tags: ["PCI DSS", "Credit Card", "Expiration Date"]
+    },
+    track1Data: {
+        type: "Track 1 Data",
+        pattern: XRegExp('\\b%?B\\d{1,19}\\^[A-Z\\s\'-]{2,26}\\^\\d{4}[0-9A-Za-z]{0,79}\\?\\b'),
+        description: "Matches magnetic stripe Track 1 data format.",
+        tags: ["PCI DSS", "Track Data"]
+    },
+    track2Data: {
+        type: "Track 2 Data",
+        pattern: XRegExp('\\b;\\d{1,19}=\\d{4}\\d{3}[0-9]{0,79}\\?\\b'),
+        description: "Matches magnetic stripe Track 2 data format.",
+        tags: ["PCI DSS", "Track Data"]
+    },
+    pinCode: {
+        type: "Personal Identification Number (PIN)",
+        pattern: XRegExp('\\b(?:pin)\\s*[:#]?\\s*\\d{4,6}\\b', 'i'),
+        description: "Matches 4-6 digit PIN values labeled as 'PIN'.",
+        tags: ["PCI DSS", "PIN"]
+
+    },
+    email: {
+        type: "Email Addresses and Account Identifiers",
+        pattern: XRegExp('\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b', 'i'),
+        description: "Matches standard email addresses.",
+        tags: ["Contact", "Email"]
+    },
+    itin: {
+        type: "Individual Taxpayer Identification Number (ITIN)",
+        pattern: XRegExp('(?:individual[\\s-]*taxpayer|ITIN|individual[\\s-]*taxpayer[\\s-]*number)\\s*[:#]?\\s*9\\d{2}[\\s-]?\\d{2}[\\s-]?\\d{4}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches valid ITINs starting with '9', ensuring standard formats.",
+        tags: ["Tax", "Identification", "ITIN"]
+    },
+    alienRegistrationNumber: {
+        type: "Alien Registration Number",
+        pattern: XRegExp('(?:alien[\\s-]*registration|A[\\s-]*number|alien[\\s-]*number|USCIS[\\s-]*number)\\s*[:#]?\\s*A?\\d{7,9}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches alien registration numbers, often starting with 'A'.",
+        tags: ["Identification", "Alien Registration", "Immigration"]
+    },
+    tin: {
+        type: "Tax Identification Number (TIN)",
+        pattern: XRegExp('(?:tax[\\s-]*identification|TIN|tax[\\s-]*ID|tax[\\s-]*number)\\s*[:#]?\\s*(\\d{3}[\\s-]?\\d{2}[\\s-]?\\d{4})\\b(?!\\s*\\w)', 'i'),
+        description: "Matches tax ID numbers following standard TIN formats.",
+        tags: ["Tax", "Identification", "TIN"]
+    },
+    ein: {
+        type: "Employer Identification Number (EIN)",
+        pattern: XRegExp('(?:employer[\\s-]*identification|EIN|employer[\\s-]*ID|employer[\\s-]*number)\\s*[:#]?\\s*(\\d{2}[\\s-]?\\d{7})\\b(?!\\s*\\w)', 'i'),
+        description: "Matches 9-digit EIN numbers with common labels.",
+        tags: ["Tax", "Employer", "EIN"]
+    },
+    ptin: {
+        type: "Preparer Tax Identification Number (PTIN)",
+        pattern: XRegExp('(?:preparer[\\s-]*tax|PTIN|preparer[\\s-]*tax[\\s-]*ID|preparer[\\s-]*number)\\s*[:#]?\\s*P?\\d{8}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches PTINs, typically prefixed with 'P'.",
+        tags: ["Tax", "Preparation", "PTIN"]
+    },
+    caf: {
+        type: "Centralized Authorization File (CAF) Number",
+        pattern: XRegExp('(?:centralized[\\s-]*authorization|CAF|central[\\s-]*authorization[\\s-]*file)\\s*[:#]?\\s*\\d{9}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches CAF numbers in common formats.",
+        tags: ["Tax", "Authorization", "CAF"]
+    },
+    bankAccountNumber: {
+        type: "Bank Account Number",
+        pattern: XRegExp('(?:account[\\s-]*number|bank[\\s-]*account|acct[\\s-]*number|bank[\\s-]*acct|bank[\\s-]*no)\\s*[:#]?\\s*\\d{8,17}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches bank account numbers labeled with common account terms.",
+        tags: ["Financial", "Bank", "Account Number"]
+    },
+    routingNumber: {
+        type: "Routing Number",
+        pattern: XRegExp('(?:routing[\\s-]*number|bank[\\s-]*routing|routing[\\s-]*no)\\s*[:#]?\\s*\\d{9}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches 9-digit routing numbers labeled as routing or bank numbers.",
+        tags: ["Financial", "Bank", "Routing"]
+    },
+    loanAccountNumber: {
+        type: "Loan Account Number",
+        pattern: XRegExp('(?:loan[\\s-]*account|loan[\\s-]*number|loan[\\s-]*ID)\\s*[:#]?\\s*\\d{8,17}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches loan account numbers, typically 8-17 digits.",
+        tags: ["Financial", "Loan", "Account Number"]
+    },
+    investmentAccountNumber: {
+        type: "Investment Account Number",
+        pattern: XRegExp('(?:investment[\\s-]*account|investment[\\s-]*number|investment[\\s-]*acct|investment[\\s-]*ID)\\s*[:#]?\\s*\\d{8,17}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches investment account numbers, usually labeled as 'investment'.",
+        tags: ["Financial", "Investment", "Account Number"]
+    },
+    cpaLicenseNumber: {
+        type: "CPA License Number",
+        pattern: XRegExp('(?:CPA[\\s-]*license|CPA[\\s-]*number|CPA[\\s-]*ID|certified[\\s-]*public[\\s-]*accountant[\\s-]*number)\\s*[:#]?\\s*[A-Za-z0-9]{5,10}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches CPA license numbers, typically alphanumeric.",
+        tags: ["Professional", "License", "CPA"]
+    },
+    eaNumber: {
+        type: "Enrolled Agent (EA) Number",
+        pattern: XRegExp('(?:enrolled[\\s-]*agent|EA[\\s-]*number|EA[\\s-]*ID)\\s*[:#]?\\s*[A-Za-z0-9]{5,10}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches EA numbers, typically alphanumeric.",
+        tags: ["Professional", "License", "EA"]
+    },
+    taxPreparerCertificationNumber: {
+        type: "Tax Preparer Certification Number",
+        pattern: XRegExp('(?:tax[\\s-]*preparer|certification[\\s-]*number|preparer[\\s-]*certification[\\s-]*ID)\\s*[:#]?\\s*\\w{5,10}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches tax preparer certification numbers with common labels.",
+        tags: ["Professional", "Certification", "Tax Preparation"]
+    },
+    businessLicenseNumber: {
+        type: "Business License Number",
+        pattern: XRegExp('(?:business[\\s-]*license|license[\\s-]*number|business[\\s-]*ID)\\s*[:#]?\\s*\\w{5,15}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches business license numbers, usually alphanumeric.",
+        tags: ["Business", "License", "ID"]
+    },
+    registeredAgentInfo: {
+        type: "Registered Agent Information",
+        pattern: XRegExp('(?:registered[\\s-]*agent|agent[\\s-]*name|agent[\\s-]*info)\\s*[:#]?\\s*([A-Za-z\\s,]+)\\b(?!\\s*\\w)', 'i'),
+        description: "Matches registered agent information typically consisting of names or titles.",
+        tags: ["Business", "Agent", "Information"]
+    },
+    dunsNumber: {
+        type: "D-U-N-S Number",
+        pattern: XRegExp('(?:D[\\s-]*U[\\s-]*N[\\s-]*S|DUNS[\\s-]*number)\\s*[:#]?\\s*\\d{9}\\b(?!\\s*\\w)', 'i'),
+        description: "Matches 9-digit D-U-N-S numbers labeled as DUNS or D-U-N-S.",
+        tags: ["Business", "D-U-N-S", "ID"]
+    }
+};
+
+
+
diff --git a/Authenticator/repo/public/ptr/fiPatterns_new.js b/Authenticator/repo/public/ptr/fiPatterns_new.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/Authenticator/repo/public/ptr/medPatterns.js b/Authenticator/repo/public/ptr/medPatterns.js
new file mode 100644
index 000000000..317181f6c
--- /dev/null
+++ b/Authenticator/repo/public/ptr/medPatterns.js
@@ -0,0 +1,243 @@
+const medPatterns = {
+
+    generalMRN: {
+        type: "General Medical Record Number (MRN)",
+        pattern: XRegExp('\\b(?:medical record|record|mrn)[#: -]+\\d{5,10}\\b', 'i'),
+        description: "Captures 'MRN' or 'medical record' followed by a 5-10 digit number, ensuring standalone format.",
+        tags: ["Medical", "Record"]
+    },
+    mrnWithSpecificPrefixes: {
+        type: "MRNs with Specific Prefixes (e.g., 'MR' or 'H')",
+        pattern: XRegExp('\\b(?:MR|H)[#: -]*\\d{5,10}(?!\\d)', 'i'),
+        description: "Matches 'MR' or 'H' prefixes with a 5-10 digit number, avoiding single-word triggers.",
+        tags: ["Medical", "Record"]
+    },
+    uuidStyleMRN: {
+        type: "UUID-style Medical Record Numbers",
+        pattern: XRegExp('\\b(?:mrn|record)[#: -]+[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\\b', 'i'),
+        description: "Matches UUID format, e.g., 'MRN# 123e4567-e89b-12d3-a456-426614174000'.",
+        tags: ["Medical", "Record"]
+    },
+    medicareMedicaidID: {
+        type: "Medicare/Medicaid IDs",
+        pattern: XRegExp('\\b(?:medicare|medicaid|id)[#: -]+[a-z0-9]{10,12}\\b', 'i'),
+        description: "Captures Medicare/Medicaid IDs with alphanumeric formats.",
+        tags: ["Medical", "Insurance"]
+    },
+    hicn: {
+        type: "Health Insurance Claim Numbers (HICNs)",
+        pattern: XRegExp('\\b(?:hicn|claim|insurance claim)[#: -]+\\d{9,11}\\b', 'i'),
+        description: "Matches HICNs, typically 9-11 digits, labeled as 'claim' or 'HICN'.",
+        tags: ["Medical", "Insurance", "Claims"]
+    },
+    insurancePolicyNumber: {
+        type: "Insurance Policy Numbers",
+        pattern: XRegExp('\\b(?:insurance policy|policy|ins)[#: -]+[a-z0-9]{8,12}\\b', 'i'),
+        description: "Matches insurance policy numbers with alphanumeric patterns.",
+        tags: ["Insurance", "Policy"]
+    },
+    medicalBillingCaseID: {
+        type: "Medical Billing Case IDs",
+        pattern: XRegExp('\\b(?:billing case|case id|billing)[#: -]+\\d{8,10}\\b', 'i'),
+        description: "Captures 8-10 digit medical billing case numbers.",
+        tags: ["Medical", "Billing"]
+    },
+    healthcareClaimNumber: {
+        type: "Healthcare Claims Numbers",
+        pattern: XRegExp('\\b(?:claim number|claim id|healthcare claim)[#: -]+\\d{9,12}\\b', 'i'),
+        description: "Matches 9-12 digit healthcare claim numbers.",
+        tags: ["Medical", "Claims"]
+    },
+    npi: {
+        type: "National Provider Identifier (NPI)",
+        pattern: XRegExp('\\b(?:NPI|provider number)[#: -]+\\d{10}\\b', 'i'),
+        description: "Captures 10-digit NPI numbers labeled as 'NPI' or 'provider number'.",
+        tags: ["Medical", "Provider"]
+    },
+    providerFacilityNumber: {
+        type: "Provider Facility Numbers",
+        pattern: XRegExp('\\b(?:provider facility|facility id|facility number)[#: -]+\\d{8,10}\\b', 'i'),
+        description: "Matches 8-10 digit provider facility numbers.",
+        tags: ["Medical", "Provider", "Facility"]
+    },
+    facilityID: {
+        type: "Facility Identification Numbers",
+        pattern: XRegExp('\\b(?:facility id|facility number)[#: -]+[1-4]\\d{9}\\b', 'i'),
+        description: "Matches 10-digit facility IDs starting with 1-4, labeled as 'facility id'.",
+        tags: ["Medical", "Facility"]
+    },
+    cptIcdCode: {
+        type: "CPT/ICD-10 Codes",
+        pattern: XRegExp('\\b(?:cpt|icd[-\\s]*10)[#: -]+[a-z]\\d{2,3}\\b', 'i'),
+        description: "Captures CPT or ICD-10 codes (1 letter followed by 2-3 digits).",
+        tags: ["Medical", "Coding"]
+    },
+    icdSubcategoryCode: {
+        type: "ICD-10 with Subcategory Codes",
+        pattern: XRegExp('\\b(?:icd[-\\s]*10)[#: -]+[a-z]\\d{2}\\.\\d{1,2}\\b', 'i'),
+        description: "Matches ICD-10 codes with subcategories, e.g., 'A12.34'.",
+        tags: ["Medical", "Coding"]
+    },
+    drgCode: {
+        type: "Diagnosis-related Group (DRG) Codes",
+        pattern: XRegExp('\\b(?:drg|diagnosis-related group)[#: -]+\\d{3}\\b', 'i'),
+        description: "Matches 3-digit DRG codes labeled as 'DRG'.",
+        tags: ["Medical", "Coding"]
+    },
+    specialtyProcedureCode: {
+        type: "Specialty Procedure Codes",
+        pattern: XRegExp('\\b(?:specialty procedure|procedure code)[#: -]+\\w{3,6}\\b', 'i'),
+        description: "Captures alphanumeric specialty procedure codes (3-6 characters).",
+        tags: ["Medical", "Procedure"]
+    },
+    labTestID: {
+        type: "Lab Test Identification Numbers",
+        pattern: XRegExp('\\b(?:lab test|test id|test number)[#: -]+\\d{8,12}\\b', 'i'),
+        description: "Matches 8-12 digit lab test ID numbers.",
+        tags: ["Medical", "Laboratory"]
+    },
+    referenceLabTestID: {
+        type: "Reference Lab Test IDs",
+        pattern: XRegExp('\\b(?:reference lab|lab id|reference test)[#: -]+\\d{8,10}\\b', 'i'),
+        description: "Matches reference lab test IDs with 8-10 digits.",
+        tags: ["Medical", "Laboratory"]
+    },
+    labRequisitionID: {
+        type: "Laboratory Requisition IDs",
+        pattern: XRegExp('\\b(?:lab requisition|requisition id)[#: -]+\\d{7,10}\\b', 'i'),
+        description: "Matches laboratory requisition IDs, typically 7-10 digits.",
+        tags: ["Medical", "Laboratory", "Requisition"]
+    },
+    labProcessingID: {
+        type: "Laboratory Processing IDs",
+        pattern: XRegExp('\\b(?:processing id|lab process)[#: -]+\\d{7,10}\\b', 'i'),
+        description: "Matches 7-10 digit lab processing IDs.",
+        tags: ["Medical", "Laboratory"]
+    },
+    rxNumber: {
+        type: "Pharmacy Prescription Numbers",
+        pattern: XRegExp('\\b(?:prescription|rx number|rx)[#: -]+\\d{6,10}\\b', 'i'),
+        description: "Captures 6-10 digit pharmacy prescription numbers.",
+        tags: ["Pharmacy", "Prescription"]
+    },
+    pharmacyProcessingCode: {
+        type: "Pharmacy Processing Codes",
+        pattern: XRegExp('\\b(?:pharmacy process|process code)[#: -]+[a-z0-9]{5,10}\\b', 'i'),
+        description: "Matches pharmacy processing codes with alphanumeric format.",
+        tags: ["Pharmacy", "Processing"]
+    },
+    specialtyDrugID: {
+        type: "Specialty Drug IDs",
+        pattern: XRegExp('\\b(?:specialty drug|drug id|drug number)[#: -]+\\d{5,10}\\b', 'i'),
+        description: "Matches specialty drug IDs, typically 5-10 digits.",
+        tags: ["Pharmacy", "Drug"]
+    },
+    substanceControlNumber: {
+        type: "Substance Control Numbers",
+        pattern: XRegExp('\\b(?:substance control|control number)[#: -]+[a-z0-9]{7,10}\\b', 'i'),
+        description: "Captures substance control numbers, allowing alphanumeric.",
+        tags: ["Pharmacy", "Control"]
+    },
+    drugAuthCode: {
+        type: "Drug Authorization Codes",
+        pattern: XRegExp('\\b(?:authorization code|drug auth|auth code)[#: -]+\\w{6,10}\\b', 'i'),
+        description: "Matches drug authorization codes with alphanumeric format.",
+        tags: ["Pharmacy", "Authorization"]
+    },
+    uniquePatientID: {
+        type: "Unique Patient Identifiers (UPIs)",
+        pattern: XRegExp('\\b(?:upi|patient id)[#: -]+[a-z0-9]{8,12}\\b', 'i'),
+        description: "Captures UPIs, allowing alphanumeric with 8-12 characters.",
+        tags: ["Medical", "Patient", "Identifier"]
+    },
+    hospitalAccountNumber: {
+        type: "Hospital Account Numbers (HAN)",
+        pattern: XRegExp('\\b(?:hospital account|han)[#: -]+\\d{6,10}\\b', 'i'),
+        description: "Matches 6-10 digit hospital account numbers (HANs).",
+        tags: ["Hospital", "Account"]
+    },
+    hospitalVisitNumber: {
+        type: "Hospital Visit Numbers",
+        pattern: XRegExp('\\b(?:visit number|hospital visit)[#: -]+\\d{6,10}\\b', 'i'),
+        description: "Matches hospital visit numbers, typically 6-10 digits.",
+        tags: ["Hospital", "Visit"]
+    },
+    therapySessionID: {
+        type: "Therapy Session IDs",
+        pattern: XRegExp('\\b(?:therapy session|session id|therapy id)[#: -]+\\d{6,10}\\b', 'i'),
+        description: "Matches therapy session IDs with 6-10 digits.",
+        tags: ["Therapy", "Session"]
+    },
+    patientReferralID: {
+        type: "Patient Referral IDs",
+        pattern: XRegExp('\\b(?:referral id|referral number|patient referral)[#: -]+\\w{5,10}\\b', 'i'),
+        description: "Captures patient referral IDs with alphanumeric 5-10 characters.",
+        tags: ["Medical", "Patient", "Referral"]
+    },
+    patientConditionCode: {
+        type: "Patient Condition Group Codes",
+        pattern: XRegExp('\\b(?:condition group|group code|condition code)[#: -]+\\d{3,5}\\b', 'i'),
+        description: "Matches 3-5 digit patient condition group codes.",
+        tags: ["Medical", "Condition", "Group"]
+    },
+    medicalEligibilityNumber: {
+        type: "Medical Eligibility Numbers",
+        pattern: XRegExp('\\b(?:eligibility number|medical eligibility|eligibility id)[#: -]+\\d{8,10}\\b', 'i'),
+        description: "Captures medical eligibility numbers with 8-10 digits.",
+        tags: ["Medical", "Eligibility"]
+    },
+    clinicalTrialID: {
+        type: "Clinical Trial IDs",
+        pattern: XRegExp('\\b(?:clinical trial|trial id|trial number)[#: -]+[a-z0-9]{8,12}\\b', 'i'),
+        description: "Matches clinical trial IDs, allowing alphanumeric format.",
+        tags: ["Medical", "Trial"]
+    },
+    clinicalDocumentationCode: {
+        type: "Clinical Documentation Codes",
+        pattern: XRegExp('\\b(?:clinical doc|documentation id|doc code)[#: -]+[a-z0-9]{6,10}\\b', 'i'),
+        description: "Captures clinical documentation codes with 6-10 alphanumeric.",
+        tags: ["Medical", "Documentation"]
+    },
+    authForServiceID: {
+        type: "Authorization for Service IDs",
+        pattern: XRegExp('\\b(?:authorization|service id|auth id)[#: -]+\\d{8,12}\\b', 'i'),
+        description: "Matches authorization for service IDs with 8-12 digits.",
+        tags: ["Medical", "Authorization"]
+    },
+    medicalImagingReportNumber: {
+        type: "Medical Imaging Report Numbers",
+        pattern: XRegExp('\\b(?:imaging report|report id|imaging id)[#: -]+\\d{7,10}\\b', 'i'),
+        description: "Matches 7-10 digit medical imaging report numbers.",
+        tags: ["Medical", "Imaging"]
+    },
+    therapyOrderNumber: {
+        type: "Therapy Order Numbers",
+        pattern: XRegExp('\\b(?:therapy order|order id|therapy id)[#: -]+\\d{7,10}\\b', 'i'),
+        description: "Captures therapy order numbers with 7-10 digits.",
+        tags: ["Therapy", "Order"]
+    },
+    geneticTestID: {
+        type: "Genetic Testing IDs",
+        pattern: XRegExp('\\b(?:genetic test|genetic id|testing id)[#: -]+\\w{6,12}\\b', 'i'),
+        description: "Matches genetic testing IDs with 6-12 alphanumeric characters.",
+        tags: ["Medical", "Genetic"]
+    },
+    geneticServiceID: {
+        type: "Genetic Service IDs",
+        pattern: XRegExp('\\b(?:genetic service|service id|genetic id)[#: -]+\\d{6,10}\\b', 'i'),
+        description: "Captures genetic service IDs with 6-10 digits.",
+        tags: ["Medical", "Genetic"]
+    },
+    medicalReferenceNumber: {
+        type: "Medical Reference Numbers",
+        pattern: XRegExp('\\b(?:medical ref|reference id|ref number)[#: -]+\\d{6,10}\\b', 'i'),
+        description: "Matches medical reference numbers, typically 6-10 digits.",
+        tags: ["Medical", "Reference"]
+    },
+    customMedicalID: {
+        type: "Custom Medical Identifier",
+        pattern: XRegExp('\\b(?:custom id|med id|custom number)[#: -]+\\w{6,12}\\b', 'i'),
+        description: "Captures custom medical identifiers with 6-12 alphanumeric characters.",
+        tags: ["Medical", "Custom"]
+    }
+};
diff --git a/Authenticator/repo/public/ptr/medPatterns_new.js b/Authenticator/repo/public/ptr/medPatterns_new.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/Authenticator/repo/public/ptr/networkPatterns.js b/Authenticator/repo/public/ptr/networkPatterns.js
new file mode 100644
index 000000000..df785e78a
--- /dev/null
+++ b/Authenticator/repo/public/ptr/networkPatterns.js
@@ -0,0 +1,110 @@
+const networkPatterns = {
+    internalIP: {
+        type: "Internal IP Address (IPv4)",
+        pattern: XRegExp('\\b(10|192\\.168|172\\.(1[6-9]|2[0-9]|3[0-1]))\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b'),
+        
+        tags: ["Network", "IP Address", "Internal"]
+    },
+    externalIP: {
+        type: "External IP Address (IPv4)",
+        pattern: XRegExp('(?<!\\d)((?!10|192\\.168|172\\.(1[6-9]|2[0-9]|3[0-1]))(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?!\\d)'),
+        
+        tags: ["Network", "IP Address", "External"]
+    },
+    ipv6Address: {
+        type: "IPv6 Address",
+        pattern: XRegExp('\\b((?:[0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4})\\b(?![:-\\w])'),
+        
+        tags: ["Network", "IP Address", "IPv6"]
+    },
+    macAddress: {
+        type: "MAC Address",
+        pattern: XRegExp('\\b([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\\b(?![:-\\w])'),
+        
+        tags: ["Network", "MAC Address", "Device"]
+    },
+    deviceHostnames: {
+        type: "Device Hostnames",
+        pattern: XRegExp('\\b(?:Hostname|Device Hostname|Host|DeviceHostname|HOSTNAME#|Device Hostname#|Host#)\\s*[#: ]\\s*(?!-)[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\\.[a-zA-Z]{2,}){1,}\\b', 'i'),
+        
+        tags: ["Network", "Device", "Hostname"]
+    },
+    subnetInfo: {
+        type: "Subnet Information",
+        pattern: XRegExp('\\b(?:Subnet|Netmask|CIDR|Subnet Info|Network)\\s*[:# ]\\s*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])\\/(3[0-2]|[1-2]?[0-9])\\b(?![\\d.-])', 'i'),
+        
+        tags: ["Network", "Subnet", "CIDR"]
+    },
+    firewallRules: {
+        type: "Firewall Rules and Policies",
+        pattern: XRegExp('\\b(allow|deny|reject|accept|drop|block|permit|iptable|firewall-rule|fw-rule|acl-entry)\\s+(rule|policy|config|setting)\\b', 'i'),
+        
+        tags: ["Network", "Security", "Firewall"]
+    },
+    certsAndKeys: {
+        type: "Certificates and Private Keys",
+        pattern: XRegExp('-----BEGIN\\s+(CERTIFICATE|PRIVATE\\s+KEY|RSA\\s+PRIVATE\\s+KEY|EC\\s+PRIVATE\\s+KEY)-----[\\r\\n]+([A-Za-z0-9+/=\\r\\n]+)[\\r\\n]+-----END\\s+\\1-----', 'gi'),
+        
+        tags: ["Security", "Certificate", "Private Key"]
+    },
+    deviceSerials: {
+        type: "Device Serial Numbers",
+        pattern: XRegExp('\\b(?:Serial(?:\\s*Number)?|Serial#|SN|S\\/N|SER#|Device Serial(?:\\s*Number)?)\\s*[#: ]\\s*[A-Z0-9-]{8,20}\\b', 'i'),
+        
+        tags: ["Device", "Serial Number", "Asset"]
+    },
+    accessControlLists: {
+        type: "Access Control Lists (ACLs)",
+        pattern: XRegExp('\\bconfig\\s+firewall\\s+acl[6]?\\s+edit\\s+\\d+\\s+set\\s+interface\\s+"[^"]+"\\s+set\\s+srcaddr\\s+"[^"]+"\\s+set\\s+dstaddr\\s+"[^"]+"\\s+set\\s+service\\s+"[^"]+"\\s+next\\s+end\\b'),
+        
+        tags: ["Network", "Security", "ACL"]
+    },
+    packetCaptures: {
+        type: "Packet Captures (PCAP files)",
+        pattern: XRegExp('\\b([\\w-]+)\\.(pcap|pcapng)\\b', 'i'),
+        
+        tags: ["Network", "Packet Capture", "File"]
+    },
+    networkLogs: {
+        type: "Logs of Network Traffic",
+        pattern: XRegExp('\\b(packet|bytes|ip|source|destination|protocol|length|flags|ttl|seq|ack|tcp|udp|transmit|receive|data|latency|throughput)\\s+(log|capture|traffic)\\b', 'i'),
+        
+        tags: ["Network", "Traffic", "Log"]
+    },
+    assetTags: {
+        type: "Asset Tags",
+        pattern: XRegExp('\\b(?:Asset Tag|Asset#|AssetTag|ATAG|Asset)\\s*[#: ]\\s*[A-Z0-9]{8,16}\\b', 'i'),
+        
+        tags: ["Asset", "Device", "Tag"]
+    },
+    networkMetadata: {
+        type: "Network Metadata (timestamps, size of data transfers, etc.)",
+        pattern: XRegExp('\\b(?:Timestamp|Date|Time|Size|Data Transfer)\\s*[:# ]\\s*(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}|\\d{2}:\\d{2}:\\d{2}|\\d+\\s+(bytes|KB|MB|GB|TB))\\b', 'i'),
+        
+        tags: ["Network", "Metadata", "Data Transfer"]
+    },
+    sshRSAKey: {
+        type: "SSH RSA Key",
+        pattern: XRegExp('\\bssh-rsa\\s+[A-Za-z0-9+/=]{20,512}(?:\\s+[\\w@.-]+)?\\b'),
+        
+        tags: ["Security", "SSH", "Key"]
+    },
+    sshDSSKey: {
+        type: "SSH DSS Key",
+        pattern: XRegExp('\\bssh-dss\\s+[A-Za-z0-9+/=]{20,512}(?:\\s+[\\w@.-]+)?\\b'),
+        
+        tags: ["Security", "SSH", "Key"]
+    },
+    sshECDSAKey: {
+        type: "SSH ECDSA Key",
+        pattern: XRegExp('\\becdsa-sha2-nistp256\\s+[A-Za-z0-9+/=]{20,512}(?:\\s+[\\w@.-]+)?\\b'),
+        
+        tags: ["Security", "SSH", "Key"]
+    },
+    sshED25519Key: {
+        type: "SSH ED25519 Key",
+        pattern: XRegExp('\\bssh-ed25519\\s+[A-Za-z0-9+/=]{20,512}(?:\\s+[\\w@.-]+)?\\b'),
+        
+        tags: ["Security", "SSH", "Key"]
+    }
+};
diff --git a/Authenticator/repo/public/ptr/networkPatterns_new.js b/Authenticator/repo/public/ptr/networkPatterns_new.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/Authenticator/repo/public/ptr/piiPatterns.js b/Authenticator/repo/public/ptr/piiPatterns.js
new file mode 100644
index 000000000..20a428222
--- /dev/null
+++ b/Authenticator/repo/public/ptr/piiPatterns.js
@@ -0,0 +1,39 @@
+const personalIdentificationPatterns = {
+ssn: {
+    type: "Social Security Number (SSN)",
+    pattern: XRegExp('\\b(?:(?:SSN|Social Security Number)[:#\\s]*)?(?!Slot[:#\\s]*)(?!000|666|9\\d{2})\\d{3}[-](?!00)\\d{2}[-](?!0000)\\d{4}\\b(?!\\s*(password|user|account))', 'i')
+	
+  },
+  driversLicense: {
+    type: "Driver's License Number",
+    pattern: XRegExp('\\b(?:Driver(?:\'s License|DL)?\\s?(Number)?)?[:#\\s]*[A-Z]{1,2}\\d{6,8}\\b(?!\\s*(password|user|licensee|license))', 'i')
+    
+  },
+  passportNumber: {
+    type: "Passport Number",
+    pattern: XRegExp('\\b(?:Passport(?:\\sNumber)?)?[:#\\s]*[A-Z]{1}\\d{7,8}\\b(?!\\s*(password|pass|user))', 'i')
+    
+  },
+  email: {
+    type: "Email Address",
+    pattern: XRegExp('\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b(?!\\s*(password|user))', 'i')
+    
+  },
+  phoneNumber: {
+    type: "Phone Number",
+    pattern: XRegExp('\\b(?:\\+?\\d{1,3})?[-.\\s]?\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}\\b(?!\\s*(password|user|extension|pin))', 'i')
+    
+  },
+
+taxID: {
+    type: "Tax ID Number",
+    pattern: XRegExp('\\b(?:(?:TIN|Tax ID|Taxpayer Identification Number)[:#\\s]*)?(?!Slot[:#\\s]*)(?!00)\\d{2}-\\d{7}\\b(?!\\s*(password|user|tax))', 'i')
+},
+
+  
+credentials: {
+  type: "Username and Password",
+  pattern: XRegExp('\\b(?:username|user)[:\\s]+([A-Za-z0-9._%+-]+)\\s*(?:password|pass)[:\\s]+([A-Za-z0-9!@#$%^&*()_+-=]{6,})\\b', 'i')
+  
+}
+};
diff --git a/extensions.json b/extensions.json
index 40bf27be2..43a0e85ff 100644
--- a/extensions.json
+++ b/extensions.json
@@ -3,7 +3,7 @@
     {
       "id": "allmdcfldidgeghfoioaaiammdlpmnnk",
       "name": "Artifact",
-      "campaign" : "artifact",
+      "campaign": "artifact",
       "description": "An extension to earn rewards for browsing the web.",
       "version": "1.0.1",
       "author": "Wootzapp Team",
@@ -21,7 +21,7 @@
     {
       "id": "fdjkflhcgjnhmbfpbojnalpfmomjggkj",
       "name": "Wootzapp Wallet",
-      "campaign" : "wootzapp-wallet",
+      "campaign": "wootzapp-wallet",
       "description": "Wallet for Ethereum and Solana blockchain networks.",
       "version": "1.0.4",
       "author": "Wootzapp Team",
@@ -39,7 +39,7 @@
     {
       "id": "lldicgmlhdphidpnhgeiibfkifemhgal",
       "name": "AI Data Scraper",
-      "campaign" : "ai-data-scraper",
+      "campaign": "ai-data-scraper",
       "description": "An extension to earn passive money by scrolling tweets on twitter(X) using AI.",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -58,7 +58,7 @@
     {
       "id": "gpfellaldmjpgonllcjpjfpodfmgobnk",
       "name": "Tap.Eclipse",
-      "campaign" : "eclipse",
+      "campaign": "eclipse",
       "description": "Tap Eclipse website integration with wootzapp wallet.",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -76,7 +76,7 @@
     {
       "id": "kpobgdhknoakgagflffeigaojlglkbhn",
       "name": "Blockmesh Network",
-      "campaign" : "blockmesh",
+      "campaign": "blockmesh",
       "description": "BlockMesh Network allows you to generate passive income from your excessive bandwidth.",
       "version": "0.0.562",
       "author": "Wootzapp Team",
@@ -94,7 +94,7 @@
     {
       "id": "amjlbcejmaebkjfmeenkcijgpjpieepc",
       "name": "Camp Network",
-      "campaign" : "camp",
+      "campaign": "camp",
       "description": "An extension to earn passive money by scrolling tweets on twitter(X).",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -112,7 +112,7 @@
     {
       "id": "doklnekkemmhclakfekoccilofpdcncb",
       "name": "Coddata Clip",
-      "campaign" : "coddata",
+      "campaign": "coddata",
       "description": "Turn Your Intelligence into AI",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -121,46 +121,16 @@
       "github_url": "https://github.com/wootzapp/ext-store/tree/main/Coddata%20Clip/Repo",
       "tags": [
         "Rewards",
-        "AI", 
+        "AI",
         "Instagram"
       ],
       "created_at": "2025-02-26T15:00:00Z",
       "updated_at": "2025-02-26T15:00:00Z"
     },
-    {
-      "id": "lhgoolpdddhhfahbnofaomjhfhfjfhop",
-      "name": "AI Researcher",
-      "campaign" : "ai-researcher",
-      "description": "AI-powered web research assistant that provides intelligent summaries, comprehensive research, and fact-checking for any webpage using advanced language models.",
-      "version": "1.0.0",
-      "author": "Wootzapp Team",
-      "download_url": "https://raw.githubusercontent.com/wootzapp/ext-store/main/web%20summary/AIResearcher.crx",
-      "icon_url": "https://raw.githubusercontent.com/wootzapp/ext-store/main/web%20summary/repo/public/icons/icon128.png",
-      "github_url": "https://github.com/wootzapp/ext-store/tree/main/web%20summary/repo"
-    },
-    {
-      "id": "fkagldhhbbaillkjbjilcgflcihbkmoe",
-      "name": "Social Shopping Agent",
-      "description": "An extension to assist users to chat and perform tasks using AI.",
-      "version": "1.0.0",
-      "author": "Wootzapp Team",
-      "download_url": "https://raw.githubusercontent.com/wootzapp/ext-store/main/Social%20Shopping%20Agent/SocialShoppingAgent.crx",  
-      "icon_url": "https://raw.githubusercontent.com/wootzapp/ext-store/main/Social%20Shopping%20Agent/repo/public/icons/icon.png",
-      "github_url": "https://github.com/wootzapp/ext-store/tree/main/Social%20Shopping%20Agent/repo",
-      "tags": [
-        "AI Agent",
-        "Social Media",
-        "Shopping Sites",
-        "Productivity",
-        "Automation"
-      ],
-      "created_at": "2025-08-01T15:00:00Z",
-      "updated_at": "2025-08-01T15:00:00Z"
-    },
     {
       "id": "ficjckojhebnoogjmhacgodjcgddphac",
       "name": "AI Twitter Agent",
-      "campaign" : "ai-twitter-agent",
+      "campaign": "ai-twitter-agent",
       "description": "An AI Twitter Agent that can post ai generated tweets on your behalf.",
       "version": "1.0.1",
       "author": "Wootzapp Team",
@@ -179,7 +149,7 @@
     {
       "id": "mafnkcehjhddilcnhlnkbcbelilbifhm",
       "name": "ZK Proofing",
-      "campaign" : "zk-proofing",
+      "campaign": "zk-proofing",
       "description": "An extension to generate cryptographic proofs for zk-SNARKs.",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -197,7 +167,7 @@
     {
       "id": "gfciojmkoheeffnkgpfdjdkfiffnohmb",
       "name": "Data Hive",
-      "campaign" : "data-hive",
+      "campaign": "data-hive",
       "description": "An extension to earn rewards for browsing the web.",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -215,7 +185,7 @@
     {
       "id": "gckloiljabipmjohgnklademghjaoboa",
       "name": "Trex",
-      "campaign" : "trex",
+      "campaign": "trex",
       "description": "Get rewards by watching YouTube videos and using Twitter",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -233,7 +203,7 @@
     {
       "id": "nofldplihhlkcpbejlmccfafcpeejaef",
       "name": "Sapien",
-      "campaign" : "sapien",
+      "campaign": "sapien",
       "description": "Earn rewards by playing games.",
       "version": "1.0.0",
       "author": "Wootzapp Team",
@@ -249,9 +219,9 @@
       "updated_at": "2025-02-26T15:00:00Z"
     },
     {
-      "id": "fipnnjlgihhfnabhnkknhifccgoeipcm",
+      "id": "ihbhhnokdlfeegneepkokjknhjiceeag",
       "name": "Authenticator",
-      "campaign" : "authenticator",
+      "campaign": "authenticator",
       "description": "Secure SAML authentication for enterprise applications with Okta integration.",
       "version": "1.0.0",
       "author": "Wootzapp Team",