webshell

Ghost Exploiter Team Official

Directory >> /home/softsuitetech/www/DEMO/widget/

File / Folder	Size	Action
.	-
images	--	ren
widget.js	77.175KB	edt ren
widget.js backup	66.142KB	edt ren
widgetTalha.js	124.355KB	edt ren
widgettest backup 5 7 2...	267.93KB	edt ren
widgettest.js	304.186KB	edt ren
widgettest.js latest ba...	81.36KB	edt ren
widgettest.js new backu...	144.419KB	edt ren
widgettest1.js	66.142KB	edt ren

(function () {
   let widgetData = null;
   let websiteData = null;
   let widgetSettings = null;
   let isWidgetInitialized = false; // Flag to track widget initialization status
   let readerActivated = false; // Flag to track if the reader is activated

const gridItems = [{
         title: "Screen Reader",
         icon: "/screenrecorder.png",
         settingKey: "screen-reader",
         key: "ctrl+j",
      },
      {
         title: "Voice Navigation",
         icon: "/voice.png",
         settingKey: "voice-navigation",
         key: "ctrl+k",
      },
      {
         title: "Contrast +",
         icon: "/contrast.png",
         settingKey: "toggle-smart-contrast",
         key: "ctrl+x",
      },
      {
         title: "Smart Contrast",
         icon: "/smallcontrast.png",
         settingKey: "toggle-smart-contrast",
         key: "ctrl+p",
      },
      {
         title: "Highlight Links",
         icon: "/link.png",
         settingKey: "highlightLinks",
         key: "ctrl+y",
      },
      {
         title: "Bigger Text",
         icon: "/text.png",
         settingKey: "biggerText",
         key: "ctrl+o",
      },
      {
         title: "Text Spacing",
         icon: "/textspace.png",
         settingKey: "Text Spacing",
         key: "ctrl+u",
      },
      {
         title: "Pause Animation",
         icon: "/pause.png",
         settingKey: "pauseAnimation",
         key: "ctrl+w",
      },
      {
         title: "Hide Images",
         icon: "/hide.png",
         settingKey: "Hide Images",
         key: "ctrl+z",
      },
      {
         title: "Dyslexic Friendly",
         icon: "/df.png",
         settingKey: "legibleFonts",
         key: "ctrl+q",
      },
      {
         title: "Bigger Cursor",
         icon: "/arraow.png",
         settingKey: "cursor",
         key: "ctrl+a",
      },
      {
         title: "Tooltips",
         icon: "/info-circle.png",
         settingKey: "tooltip",
         key: "ctrl+b",
      },
      {
         title: "Page Structure",
         icon: "/page.png",
         settingKey: "pagestructure",
         key: "ctrl+c",
      },
      {
         title: "Line Height",
         icon: "/lineheight.png",
         settingKey: "Line Height(1.5x)",
         key: "ctrl+d",
      },
      {
         title: "Text Align",
         icon: "/textalign.png",
         settingKey: "textAlign",
         key: "ctrl+e",
      },
      {
         title: "Saturation",
         icon: "/blur.png",
         settingKey: "saturation",
         key: "ctrl+f",
      },
      {
         title: "Dictionary",
         icon: "/dictionary.png",
         settingKey: "disdictionary",
         key: "ctrl+g",
      },
      {
         title: "Key Navigation",
         icon: "/keynavigation.png",
         settingKey: "keynavigation",
         key: "ctrl+h",
      },
   ];

// Add this near the beginning of your script
   function checkForWidgetReset() {
      // Check URL for reset parameter
      const urlParams = new URLSearchParams(window.location.search);
      if (urlParams.has('resetWidget')) {
         localStorage.removeItem('widgetHidden');
         console.log("Widget visibility reset");
      }

// Or add keyboard shortcut (e.g., Alt+Shift+W)
      document.addEventListener('keydown', (e) => {
         if (e.altKey && e.shiftKey && e.key === 'W') {
            localStorage.removeItem('widgetHidden');
            console.log("Widget visibility reset by keyboard shortcut");
            location.reload();
         }
      });
   }

function shouldExcludeElement(element) {
      const widgetIframe = document.getElementById("reactWidgetIframe");
      const widgetContainer = document.getElementById("widget-container");
      const isInWidget =
         (widgetIframe &&
            (element === widgetIframe || widgetIframe.contains(element))) ||
         (widgetContainer &&
            (element === widgetContainer || widgetContainer.contains(element))) ||
         element.closest("#reactWidgetIframe") ||
         element.closest("#widget-container");

return isInWidget;
   }

function loadWidget(widgetData) {
      var iframe = document.createElement("iframe");
      iframe.title = "Widget";
      let currentHeight = "150px";
      let currentWidth = "105px";
      iframe.title = "Widget";
      iframe.setAttribute(
         "style",
         `width:${currentWidth};height:${currentHeight};position:fixed;bottom:0;right:0;
        z-index:9999;border:none;transition:width 0.3s ease, height 0.3s ease;` // Add smooth transition
      );

iframe.src = "https://golden-begonia-10b3ec.netlify.app/"
      //  "https://jovial-parfait-a290ce.netlify.app/"
      // "https://resplendent-frangipane-4a3e96.netlify.app/";
      iframe.id = "reactWidgetIframe";
      const widgetData1 = {
         website: websiteData,
         widget: widgetData,
      };

// First add a global handler for messages coming from the iframe
      // This ensures the handler is ready before the iframe loads
      if (!window.widgetMessageHandlerInitialized) {
         window.widgetMessageHandlerInitialized = true;
         window.addEventListener('message', function (event) {
            if (event.data && event.data.action === "widget-ready") {
               // When the iframe signals it's ready, send the data again
               const iframe = document.getElementById("reactWidgetIframe");
               if (iframe) {
                  console.log("Widget ready, sending data again");
                  iframe.contentWindow.postMessage({
                     action: "load-widget",
                     data: widgetData1
                  }, "*");
               }
            }

// Handle acknowledgments
            if (event.data && event.data.action === "widget-data-received") {
               console.log("Widget successfully received data");
            }
         });
      }

iframe.onload = function () {
         // Send data once on load
         console.log("Widget iframe loaded, sending initial data");
         iframe.contentWindow.postMessage({
            action: "load-widget",
            data: widgetData1
         }, "*");

// Wait a moment and send again to ensure delivery
         setTimeout(() => {
            if (iframe.contentWindow) {
               iframe.contentWindow.postMessage({
                  action: "load-widget",
                  data: widgetData1
               }, "*");
            }
         }, 1000);
      };
      document.body.appendChild(iframe);
   }

// function readPageText(rate, text) {
   //     if (window.speechSynthesis.speaking) {
   //         window.speechSynthesis.cancel();
   //     }
   //     const utterance = new SpeechSynthesisUtterance(text);
   //     utterance.rate = rate;
   //     utterance.lang = "en-US";
   //     window.speechSynthesis.speak(utterance);
   // }

async function getDefinitionFromAPI(word) {
      const apiUrl = `https://api.dictionaryapi.dev/api/v2/entries/en/${word}`;
      try {
         const response = await fetch(apiUrl);
         if (!response.ok) {
            throw new Error("Failed to fetch word definition");
         }
         const data = await response.json();
         console.log("API response:", data);
         if (data && data[0] && data[0].meanings) {
            const definitions = data[0].meanings.flatMap((meaning) =>
               meaning.definitions.map((def) => def.definition)
            );
            return {
               definitions,
               length: definitions.length
            };
         } else {
            return {
               definitions: ["Definition not found."],
               length: 1
            };
         }
      } catch (error) {
         console.error(error);
         return {
            definitions: ["Error fetching definition."],
            length: 1
         };
      }
   }

function createDefinitionModal(definitions) {
      console.log("Creating definition modal:", definitions);
      let modal = document.getElementById("definitionModal");
      if (!modal) {
         modal = document.createElement("div");
         modal.id = "definitionModal";
         modal.setAttribute(
            "style",
            // make auto
            "position:fixed;top:0;left:0;width:auto;height:100%;background-color:rgba(0,0,0,0.5);display:flex;justify-content:center;align-items:center;z-index:999999;"
         );
         const inner = document.createElement("div");
         inner.setAttribute(
            "style",
            "background-color:#fff;padding:20px;max-width:500px;width:80%;height:auto;border-radius:12px;position:relative;z-index:1000000;box-shadow:0 4px 8px rgba(0,0,0,0.1);"
         );

const closeBtn = document.createElement("span");
         closeBtn.innerHTML = "&times;";
         closeBtn.onclick = () => {
            modal.style.display = "none";
         };
         closeBtn.setAttribute(
            "style",
            "position:absolute;top:10px;right:10px;font-size:24px;cursor:pointer;color:#333;"
         );

const searchInput = document.createElement("input");
         searchInput.type = "text";
         searchInput.placeholder = "Search...";
         searchInput.setAttribute(
            "style",
            "width:100%;padding:10px;margin-bottom:20px;border:1px solid #ccc;border-radius:4px;"
         );
         searchInput.oninput = async (e) => {
            const {
               definitions
            } = await getDefinitionFromAPI(e.target.value);
            console.log("Definition:", definitions);
            document.getElementById("definitionContent").textContent =
               definitions.join("\n");
         };
         inner.appendChild(searchInput);

const textContainer = document.createElement("div");
         textContainer.id = "definitionContent";
         textContainer.setAttribute(
            "style",
            "margin-bottom:20px;padding:10px;border:1px solid #ccc;border-radius:4px;min-height:100px;"
         );
         inner.appendChild(textContainer);

const buttonContainer = document.createElement("div");
         buttonContainer.setAttribute(
            "style",
            "display:flex;gap:10px;justify-content:flex-end;"
         );

const createButton = (text, color, onClick) => {
            const button = document.createElement("button");
            button.textContent = text;
            button.onclick = onClick;
            button.setAttribute(
               `"style",
            color:#444444;border:none;cursor:pointer; background-color:#FFFFFF`
            );
            return button;
         };

const readButton = createButton("Read", "#2196F3", () => {
            const text = document.getElementById("definitionContent").textContent;
            readPageText(1, text);
         });

const spellButton = createButton("Spell", "#FF9800", () => {
            const text = document.getElementById("definitionContent").textContent;
            spellText(text);
         });

const prevButton = createButton("<", "", () => showDefinition(-1));
         const nextButton = createButton(">", "", () => showDefinition(1));

buttonContainer.appendChild(readButton);
         buttonContainer.appendChild(spellButton);
         buttonContainer.appendChild(prevButton);
         buttonContainer.appendChild(nextButton);
         inner.appendChild(buttonContainer);

inner.appendChild(closeBtn);
         modal.appendChild(inner);
         document.body.appendChild(modal);
      }

let currentDefinitionIndex = 0;

showDefinition(0);
      modal.style.display = "flex";
   }

function spellText(text) {
      if (window.speechSynthesis.speaking) {
         window.speechSynthesis.cancel();
      }
      const utterance = new SpeechSynthesisUtterance(text.split("").join(" "));
      utterance.rate = 0.5;
      utterance.lang = "en-US";
      window.speechSynthesis.speak(utterance);
   }

async function submitFeedback(data) {
      try {
         if (!data.email || !data.feedbackMessage) {
            throw new Error("Email and feedbackMessage message are required");
         }

const submitData = {
            email: data.email,
            domain: websiteData?.domain,
            feedbackType: "General Feedback",
            websiteName: websiteData?.name,
            status: "In Progress",
            feedback_message: data.feedbackMessage,
         };

function handleMessages(event) {
      const bodyStyles = document.body.style;
      console.log("Message received in widget:", event.data);

// Handle the load-widget action message
      if (event.data?.action === "load-widget") {
         console.log("Widget data received:", event.data.data);
         // The widget is already loaded, we just need to acknowledge the data
         // No need to take further action as the iframe is already handling this data
         return;
      }

if (event.data?.type == "TOGGLE_FLYOUT") {
         const iframe = document.getElementById("reactWidgetIframe");
         if (iframe) {
            if (event.data?.isFlyoutOpen) {
               requestAnimationFrame(() => {
                  iframe.style.width = "100%";
                  iframe.style.height = "100%";
               });
               iframe.contentWindow.postMessage({
                     action: "open-flyout",
                  },
                  "*"
               );
            } else {
               requestAnimationFrame(() => {
                  iframe.style.width = "105px";
                  iframe.style.height = "150px";
               });
               iframe.contentWindow.postMessage({
                     action: "close-flyout",
                  },
                  "*"
               );
               if (iframe) {
                  iframe.contentWindow.postMessage({
                     action: "unSelectedAppCursors"
                  }, "*");
               }
            }
         }
         
         if(event.data?.action == "shortcutKey"){
            const iframe123 = document.getElementById("reactWidgetIframe");
            iframe123.contentWindow.postMessage({
                action: "shortcutKey",
                data: event.data.key,
                altTrue: event.data.altKey,
            },
                "*"
            );
        }
      }

function isWebsiteGerman() {
         const bodyText = document.body.innerText.toLowerCase();
         const germanWords = ["und", "der", "die", "das", "ist", "ein", "zu", "haben", "mit", "für", "auf", "nicht"];
         const germanCount = germanWords.filter(word => bodyText.includes(word)).length;
         return germanCount > 5 || window.location.hostname.includes(".de");
      }

function detectLanguage(text) {
         const germanWords = ["und", "der", "die", "das", "ist", "ein", "zu", "haben", "mit", "für", "auf", "nicht"];
         const englishWords = ["the", "is", "and", "you", "have", "for", "on", "with", "not"];

let detectedLang = "en-US";
         const germanCount = germanWords.filter(word => text.toLowerCase().includes(word)).length;
         const englishCount = englishWords.filter(word => text.toLowerCase().includes(word)).length;

if (germanCount > englishCount) detectedLang = "de-DE";
         return detectedLang;
      }

function readPageText(rate, text, lang = "en-US") {
         if (window.speechSynthesis.speaking) {
            window.speechSynthesis.cancel();
         }

const utterance = new SpeechSynthesisUtterance(text);
         utterance.lang = lang;
         utterance.rate = rate;

function selectVoice(voices, lang) {
            let selectedVoice = voices.find(voice => voice.lang.startsWith(lang) && voice.name.includes("Male"));
            if (!selectedVoice) selectedVoice = voices.find(voice => voice.lang.startsWith(lang)); // Fallback
            return selectedVoice;
         }

function removeTextReadListeners() {
         document.removeEventListener("click", handleTextRead);
      }

// Voice Navigation function start from here

let recognition = null;
      let isListening = false;
      let lastCommand = "";
      let recognitionTimeout = null;

// Function to detect the language of the website
      function detectWebsiteLanguage() {
         // First check if the HTML tag has a lang attribute
         const htmlLang = document.documentElement.lang.toLowerCase();
         if (htmlLang.startsWith('de')) {
            return 'de-DE';
         } else if (htmlLang) {
            return 'en-US'; // Default to English for any other language
         }

// If no lang attribute, try to detect based on content or URL
         const url = window.location.href;
         if (url.includes('.de/') || url.includes('/de/')) {
            return 'de-DE';
         }

// Default to English
         return 'en-US';
      }

// Function to get translations based on language
      function getTranslations(language) {
         if (language === 'de-DE') {
            return {
               listening: "Es wird zugehört",
               clickPrompt: "klick",
               lastCommand: "Letzter Befehl",
               clickNumber: "Klicke Nummer",
               error: "Fehler: keine Sprache erkannt",
               welcome: "Sprachnavigation ist aktiviert",
               instructionsTitle: "Anleitung zur Sprachnavigation:",
               instructions: [
                  "Sprechen Sie die Nummer eines Elements, um es anzuklicken.",
                  "Klicken Sie auf das Mikrofonsymbol, um die Erkennung ein-/auszuschalten.",
                  "Versuchen Sie 'Klicke 1', 'Klicke 2', usw."
               ],
               gotIt: "Verstanden"
            };
         } else {
            return {
               listening: "Listening",
               clickPrompt: "click",
               lastCommand: "Last command",
               clickNumber: "Click number",
               error: "Error: no speech",
               welcome: "Voice navigation is activated",
               instructionsTitle: "Voice Navigation Instructions:",
               instructions: [
                  "Say the number of an element to click it.",
                  "Click the microphone icon to toggle recognition.",
                  "Try saying 'Click 1', 'Click 2', etc."
               ],
               gotIt: "Got it"
            };
         }
      }

function createSimpleVoiceNavigationBar() {
         const language = detectWebsiteLanguage();
         const translations = getTranslations(language);

// Create the main container
         const container = document.createElement('div');
         container.id = 'voice-navigation-container';
         container.style.position = 'fixed';
         container.style.bottom = '20px';
         container.style.left = '50%';
         container.style.transform = 'translateX(-50%)';
         container.style.width = '300px';
         container.style.backgroundColor = 'rgba(40, 40, 40, 0.95)';
         container.style.borderRadius = '10px';
         container.style.padding = '15px';
         container.style.boxShadow = '0 4px 8px rgba(0, 0, 0, 0.2)';
         container.style.zIndex = '9999';
         container.style.color = 'white';
         container.style.fontFamily = 'Arial, sans-serif';
         container.style.display = 'none';

// Header with status
         const header = document.createElement('div');
         header.style.display = 'flex';
         header.style.justifyContent = 'space-between';
         header.style.alignItems = 'center';

// Microphone icon and status
         const statusContainer = document.createElement('div');
         statusContainer.style.display = 'flex';
         statusContainer.style.alignItems = 'center';

const micIcon = document.createElement('div');
         micIcon.id = 'voice-mic-icon';
         micIcon.style.cursor = 'pointer';
         micIcon.innerHTML = `<svg width="24" height="24" viewBox="0 0 24 24" fill="#4B88FF">
                            <path d="M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3z"></path>
                            <path d="M17 11c0 2.76-2.24 5-5 5s-5-2.24-5-5H5c0 3.53 2.61 6.43 6 6.92V21h2v-3.08c3.39-.49 6-3.39 6-6.92h-2z"></path>
                         </svg>`;

const statusText = document.createElement('span');
         statusText.id = 'voice-status-text';
         statusText.textContent = translations.listening;
         statusText.style.marginLeft = '8px';
         statusText.style.marginRight = '8px';

statusContainer.appendChild(micIcon);
         statusContainer.appendChild(statusText);

// Last command display
         const lastCommandContainer = document.createElement('div');
         lastCommandContainer.style.display = 'flex';
         lastCommandContainer.style.alignItems = 'center';

const lastCommandText = document.createElement('span');
         lastCommandText.id = 'voice-last-command';
         lastCommandText.textContent = `${translations.lastCommand}: "${translations.clickNumber}"`;
         lastCommandText.style.marginRight = '8px';

const closeButton = document.createElement('button');
         closeButton.innerHTML = '✕';
         closeButton.style.backgroundColor = 'transparent';
         closeButton.style.border = 'none';
         closeButton.style.color = 'white';
         closeButton.style.cursor = 'pointer';
         closeButton.style.padding = '5px';
         closeButton.style.borderRadius = '50%';
         closeButton.style.width = '30px';
         closeButton.style.height = '30px';
         closeButton.style.display = 'flex';
         closeButton.style.justifyContent = 'center';
         closeButton.style.alignItems = 'center';
         closeButton.style.backgroundColor = '#555';

lastCommandContainer.appendChild(lastCommandText);
         lastCommandContainer.appendChild(closeButton);

header.appendChild(statusContainer);
         header.appendChild(lastCommandContainer);

// Append header to container
         container.appendChild(header);

// Append container to body
         document.body.appendChild(container);

// Create instructions panel (initially shown, hidden after user clicks "Got it")
         const instructionsPanel = document.createElement('div');
         instructionsPanel.id = 'voice-instructions-panel';
         instructionsPanel.style.position = 'fixed';
         instructionsPanel.style.bottom = '80px';
         instructionsPanel.style.left = '50%';
         instructionsPanel.style.transform = 'translateX(-50%)';
         instructionsPanel.style.width = '320px';
         instructionsPanel.style.backgroundColor = 'rgba(40, 40, 40, 0.95)';
         instructionsPanel.style.borderRadius = '10px';
         instructionsPanel.style.padding = '15px';
         instructionsPanel.style.boxShadow = '0 4px 8px rgba(0, 0, 0, 0.2)';
         instructionsPanel.style.zIndex = '9998';
         instructionsPanel.style.color = 'white';
         instructionsPanel.style.fontFamily = 'Arial, sans-serif';

const instructionsTitle = document.createElement('div');
         instructionsTitle.textContent = translations.instructionsTitle;
         instructionsTitle.style.fontWeight = 'bold';
         instructionsTitle.style.marginBottom = '10px';
         instructionsPanel.appendChild(instructionsTitle);

const instructionsList = document.createElement('ul');
         instructionsList.style.paddingLeft = '20px';
         instructionsList.style.marginBottom = '15px';

translations.instructions.forEach(instruction => {
            const listItem = document.createElement('li');
            listItem.textContent = instruction;
            listItem.style.marginBottom = '5px';
            instructionsList.appendChild(listItem);
         });

instructionsPanel.appendChild(instructionsList);

const gotItButton = document.createElement('button');
         gotItButton.textContent = translations.gotIt;
         gotItButton.style.backgroundColor = '#4B88FF';
         gotItButton.style.border = 'none';
         gotItButton.style.color = 'white';
         gotItButton.style.borderRadius = '5px';
         gotItButton.style.padding = '8px 15px';
         gotItButton.style.cursor = 'pointer';
         gotItButton.style.display = 'block';
         gotItButton.style.margin = '0 auto';

instructionsPanel.appendChild(gotItButton);
         document.body.appendChild(instructionsPanel);
         instructionsPanel.style.display = 'none';

// Event listeners
         closeButton.addEventListener('click', () => {
            disableVoiceNavigation();
            container.style.display = 'none';
            instructionsPanel.style.display = 'none';
         });

micIcon.addEventListener('click', () => {
            if (isListening) {
               stopVoiceRecognition();
            } else {
               startVoiceRecognition();
            }
         });

gotItButton.addEventListener('click', () => {
            instructionsPanel.style.display = 'none';
         });

return {
            container: container,
            instructionsPanel: instructionsPanel
         };
      }

function enableVoiceNavigationWithUI() {
         // Create or show the navigation bar
         let container = document.getElementById('voice-navigation-container');
         let instructionsPanel = document.getElementById('voice-instructions-panel');

if (!container) {
            const elements = createSimpleVoiceNavigationBar();
            container = elements.container;
            instructionsPanel = elements.instructionsPanel;
         }

container.style.display = 'block';
         instructionsPanel.style.display = 'block';

// Enable voice navigation functionality
         removeExistingVoiceNumbers();
         addVoiceNumbersToElements();

// Request microphone permission with user interaction and proper error handling
         requestMicrophonePermission().then(permissionGranted => {
            if (permissionGranted) {
               startVoiceRecognition();

// Save state to localStorage for persistence
               localStorage.setItem('voiceNavigationEnabled', 'true');

// Say welcome message
               const language = detectWebsiteLanguage();
               const translations = getTranslations(language);
               readPageText(translations.welcome, language);
            } else {
               // Handle denied permission
               showPermissionError(container);
            }
         });
      }

// Add this new function to handle permission requests
      function requestMicrophonePermission() {
         return new Promise((resolve) => {
            // First check if permission is already granted
            navigator.permissions.query({
               name: 'microphone'
            }).then(permissionStatus => {
               if (permissionStatus.state === 'granted') {
                  resolve(true);
               } else if (permissionStatus.state === 'denied') {
                  resolve(false);
               } else {
                  // Need to request permission - this must be triggered by user action
                  // We'll try to start recognition which will trigger the browser request
                  try {
                     const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
                     const tempRecognition = new SpeechRecognition();

// Set up listeners for success/failure
                     tempRecognition.onstart = () => {
                        tempRecognition.stop(); // Immediately stop after permission granted
                        resolve(true);
                     };

tempRecognition.onerror = (event) => {
                        console.error("Permission error:", event.error);
                        resolve(false);
                     };

// Start recognition to trigger permission request
                     tempRecognition.start();
                  } catch (error) {
                     console.error("Speech recognition not supported:", error);
                     resolve(false);
                  }
               }
            }).catch(error => {
               console.error("Permission query failed:", error);
               resolve(false);
            });
         });
      }

// Add this function to show permission error
      function showPermissionError(container) {
         const errorMsg = document.createElement('div');
         errorMsg.className = 'voice-permission-error';
         errorMsg.innerHTML = `
        <div style="background-color: #ffdddd; color: #990000; padding: 10px; margin: 10px 0; border-radius: 5px;">
            <strong>Microphone permission required!</strong>
            <p>Please allow microphone access in your browser settings to use voice navigation.</p>
            <button id="retry-voice-permission" style="background: #007bff; color: white; border: none; padding: 5px 10px; border-radius: 3px; cursor: pointer;">
                Try Again
            </button>
        </div>
    `;

container.appendChild(errorMsg);

// Add click handler for retry button
         document.getElementById('retry-voice-permission').addEventListener('click', () => {
            errorMsg.remove();
            requestMicrophonePermission().then(granted => {
               if (granted) {
                  startVoiceRecognition();
                  localStorage.setItem('voiceNavigationEnabled', 'true');
               } else {
                  showPermissionError(container);
               }
            });
         });
      }

// Add a function to check for persisted state on page load
      function checkForPersistedVoiceNavigation() {
         if (localStorage.getItem('voiceNavigationEnabled') === 'true') {
            console.log("Restoring voice navigation from previous session");
            enableVoiceNavigationWithUI();
         }
      }

function disableVoiceNavigation() {
         removeExistingVoiceNumbers();
         stopVoiceRecognition();

const container = document.getElementById('voice-navigation-container');
         const instructionsPanel = document.getElementById('voice-instructions-panel');

if (container) {
            container.style.display = 'none';
         }

if (instructionsPanel) {
            instructionsPanel.style.display = 'none';
         }

// Clear the persisted state
         localStorage.removeItem('voiceNavigationEnabled');
      }

function disableVoiceNavigation() {
         removeExistingVoiceNumbers();
         stopVoiceRecognition();

const container = document.getElementById('voice-navigation-container');
         const instructionsPanel = document.getElementById('voice-instructions-panel');

if (container) {
            container.style.display = 'none';
         }

if (instructionsPanel) {
            instructionsPanel.style.display = 'none';
         }
      }

function removeExistingVoiceNumbers() {
         document.querySelectorAll(".voice-number-label").forEach(el => el.remove());

// Also remove any container we might have created
         const container = document.getElementById('voice-number-container');
         if (container) {
            container.remove();
         }
      }

// Create a containerized element for number labels
      function createNumberContainer() {
         let container = document.getElementById('voice-number-container');
         if (!container) {
            container = document.createElement('div');
            container.id = 'voice-number-container';
            container.style.position = 'absolute';
            container.style.top = '0';
            container.style.left = '0';
            container.style.width = '100%';
            container.style.height = '0';
            container.style.overflow = 'visible';
            container.style.pointerEvents = 'none'; // Make it non-interactive
            container.style.zIndex = '9998';
            document.body.appendChild(container);
         }
         return container;
      }

function addVoiceNumbersToElements() {
         removeExistingVoiceNumbers();

// Create a container for all number labels
         const numberContainer = createNumberContainer();

// Array to store valid clickable elements
         const validElements = [];

// First priority: Navigation links
         collectValidElements("nav a, nav button", validElements);

// Second priority: Other commonly clickable elements
         collectValidElements("a[href], button:not([disabled]), input[type='submit']:not([disabled]), input[type='button']:not([disabled])", validElements);

// Number all collected elements
         for (let i = 0; i < validElements.length; i++) {
            const element = validElements[i];
            const count = i + 1;
            addNumberLabel(element, count, numberContainer);
         }
      }

function collectValidElements(selector, validElements) {
         document.querySelectorAll(selector).forEach(element => {
            // Skip if already in our array
            if (validElements.includes(element)) {
               return;
            }

// Skip hidden or disabled elements
            if (!isReallyClickable(element)) {
               return;
            }

validElements.push(element);
         });
      }

function isReallyClickable(element) {
         // Get computed style
         const style = window.getComputedStyle(element);

// Check if element is hidden or has no dimensions
         if (style.display === "none" ||
            style.visibility === "hidden" ||
            style.opacity === "0" ||
            element.disabled ||
            element.getAttribute("aria-hidden") === "true") {
            return false;
         }

// For links, ensure they have an href
         if (element.tagName.toLowerCase() === 'a' && !element.getAttribute('href')) {
            return false;
         }

// Check if element has dimensions
         const rect = element.getBoundingClientRect();
         if (rect.width <= 1 || rect.height <= 1) {
            return false;
         }

// Check if element is actually clickable with a click handler or href
         const hasClickHandler = element.onclick ||
            element.getAttribute('onclick') ||
            element.getAttribute('href') ||
            element.tagName.toLowerCase() === 'button' ||
            (element.tagName.toLowerCase() === 'input' &&
               (element.type === 'submit' || element.type === 'button'));

return hasClickHandler;
      }

function addNumberLabel(element, count, container) {
         let rect = element.getBoundingClientRect();

// Create the label
         let label = document.createElement("div");
         label.classList.add("voice-number-label");
         label.innerText = count;
         label.style.position = "absolute";
         label.style.background = "#000";
         label.style.color = "#fff";
         label.style.fontSize = "12px";
         label.style.padding = "2px 4px";
         label.style.borderRadius = "50%";
         label.style.fontWeight = "bold";
         label.style.userSelect = "none";
         label.style.pointerEvents = "none"; // Don't interfere with clicks
         label.style.lineHeight = '1';
         label.style.textAlign = 'center';
         label.style.minWidth = '16px';
         label.style.minHeight = '16px';
         label.style.boxSizing = 'border-box';

// Position centered above the element
         const scrollX = window.pageXOffset || document.documentElement.scrollLeft;
         const scrollY = window.pageYOffset || document.documentElement.scrollTop;

// Position relative to element - adjust for minimum distance from edges
         const MINIMUM_EDGE_DISTANCE = 5; // minimum pixels from edge

// Calculate left position
         let leftPos = rect.left + scrollX + (rect.width / 2) - 8; // Center horizontally
         // Keep within page bounds
         leftPos = Math.max(scrollX + MINIMUM_EDGE_DISTANCE, leftPos);
         leftPos = Math.min(scrollX + window.innerWidth - 20 - MINIMUM_EDGE_DISTANCE, leftPos);

// Calculate top position - usually just above the element
         let topPos = rect.top + scrollY - 16; // Position above element
         // If too close to top of page, position it inside the element near the top
         if (topPos < scrollY + MINIMUM_EDGE_DISTANCE) {
            topPos = rect.top + scrollY + MINIMUM_EDGE_DISTANCE;
         }

label.style.left = `${leftPos}px`;
         label.style.top = `${topPos}px`;

// Store the corresponding element number for voice commands
         element.dataset.voiceNumber = count;

// Add to container
         container.appendChild(label);
      }

function startVoiceRecognition() {
         if (!window.SpeechRecognition && !window.webkitSpeechRecognition) {
            console.warn("⚠️ Voice recognition is not supported.");
            return;
         }

const language = detectWebsiteLanguage();
         const translations = getTranslations(language);

const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
         recognition = new SpeechRecognition();
         recognition.lang = language;
         recognition.continuous = true;
         recognition.interimResults = false;

isListening = true;
         updateVoiceUIStatus(true, translations.listening);

// Set timeout to detect silence
         if (recognitionTimeout) {
            clearTimeout(recognitionTimeout);
         }
         recognitionTimeout = setTimeout(() => {
            updateVoiceUIStatus(false, translations.error);
         }, 60000); // Check for silence after 60 seconds

recognition.onresult = function (event) {
            // Reset the timeout whenever we get a result
            if (recognitionTimeout) {
               clearTimeout(recognitionTimeout);
            }
            recognitionTimeout = setTimeout(() => {
               updateVoiceUIStatus(false, translations.error);
            }, 60000);

let command = event.results[event.results.length - 1][0].transcript.trim().toLowerCase();
            lastCommand = command;

// Update UI with last command
            updateLastCommand(command);

// Process the voice command
            processVoiceCommand(command, language);
         };

recognition.onerror = function (event) {
            console.error("⚠️ Voice Recognition Error:", event.error);
            const translations = getTranslations(language);
            updateVoiceUIStatus(false, translations.error);

// If there's an error, restart recognition after a short delay
            setTimeout(() => {
               if (isListening) {
                  recognition.stop();
                  recognition.start();
                  updateVoiceUIStatus(true, translations.listening);
               }
            }, 2000);
         };

recognition.onend = function () {
            // If recognition ends but we still want to be listening, restart it
            if (isListening) {
               try {
                  recognition.start();
               } catch (e) {
                  console.error("Failed to restart recognition:", e);
                  isListening = false;
                  updateVoiceUIStatus(false, translations.error);
               }
            }
         };

recognition.start();
         console.log(`🎙️ Voice recognition started in ${language}...`);
      }

function updateVoiceUIStatus(isActive, message) {
         const container = document.getElementById('voice-navigation-container');
         if (!container) return;

const statusText = document.getElementById('voice-status-text');
         if (statusText) {
            statusText.textContent = message;
         }

// Update microphone icon color based on status
         const micIcon = document.getElementById('voice-mic-icon');
         if (micIcon && micIcon.querySelector('svg')) {
            micIcon.querySelector('svg').style.fill = isActive ? '#4B88FF' : '#FF5555';
         }
      }

function updateLastCommand(command) {
         const lastCommandText = document.getElementById('voice-last-command');
         if (!lastCommandText) return;

const language = detectWebsiteLanguage();
         const translations = getTranslations(language);
         lastCommandText.textContent = `${translations.lastCommand}: "${command}"`;
      }

function processVoiceCommand(command, language) {
         let words = command.split(" ");
         let number = null;

if (language === 'de-DE') {
            // Process German commands
            // In German, find numbers in the command
            const germanNumbers = {
               'eins': 1,
               'zwei': 2,
               'drei': 3,
               'vier': 4,
               'fünf': 5,
               'sechs': 6,
               'sieben': 7,
               'acht': 8,
               'neun': 9,
               'zehn': 10,
               'elf': 11,
               'zwölf': 12,
               'dreizehn': 13,
               'vierzehn': 14,
               'fünfzehn': 15,
               'sechzehn': 16,
               'siebzehn': 17,
               'achtzehn': 18,
               'neunzehn': 19,
               'zwanzig': 20
            };

// Try to find German number words
            for (let word of words) {
               if (germanNumbers[word]) {
                  number = germanNumbers[word];
                  break;
               }
               // Also try to parse direct numbers
               const parsedNum = parseInt(word);
               if (!isNaN(parsedNum)) {
                  number = parsedNum;
                  break;
               }
            }
         } else {
            // Process English commands
            for (let word of words) {
               const parsedNum = parseInt(word);
               if (!isNaN(parsedNum)) {
                  number = parsedNum;
                  break;
               }
            }
         }

// Handle number commands
         if (!isNaN(number) && number !== null) {
            let element = document.querySelector(`[data-voice-number='${number}']`);
            if (element) {
               // Scroll element into view if needed
               if (!isElementInViewport(element)) {
                  element.scrollIntoView({
                     behavior: 'smooth',
                     block: 'center'
                  });

// Wait a bit for scrolling to complete before clicking
                  setTimeout(() => {
                     element.click();
                     console.log(`✅ Clicked on element number ${number}`);
                  }, 500);
               } else {
                  element.click();
                  console.log(`✅ Clicked on element number ${number}`);
               }
            } else {
               console.warn(`⚠️ No element found for number ${number}`);
            }
         }
      }

function isElementInViewport(el) {
         const rect = el.getBoundingClientRect();
         return (
            rect.top >= 0 &&
            rect.left >= 0 &&
            rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
            rect.right <= (window.innerWidth || document.documentElement.clientWidth)
         );
      }

function stopVoiceRecognition() {
         if (recognition) {
            recognition.stop();
            isListening = false;

const language = detectWebsiteLanguage();
            const translations = getTranslations(language);
            updateVoiceUIStatus(false, translations.listening + " (stopped)");

// Clear any active timeouts
            if (recognitionTimeout) {
               clearTimeout(recognitionTimeout);
               recognitionTimeout = null;
            }

console.log("🚫 Voice recognition stopped.");
         }
      }

// Function to read text aloud
      // function readPageText(text, language) {
      //     const utterance = new SpeechSynthesisUtterance(text);
      //     utterance.lang = language;
      //     utterance.volume = 1;
      //     utterance.rate = 1;
      //     utterance.pitch = 1;
      //     window.speechSynthesis.speak(utterance);
      // }

// Handle window resize - reposition number labels
      window.addEventListener('resize', function () {
         if (isListening) {
            // Completely rebuild the number labels on resize
            removeExistingVoiceNumbers();
            addVoiceNumbersToElements();
         }
      });

// VOice natigation function end here

// Dictionary Popup functions starts from here 
      async function getDefinitionFromAPI(word) {
         const detectedLang = detectLanguage(word); // Detect if it's German or English
         const apiURL = `https://api.dictionaryapi.dev/api/v2/entries/${detectedLang}/${word}`;

try {
            const response = await fetch(apiURL);
            if (!response.ok) {
               throw new Error(`API error: ${response.status}`);
            }
            const data = await response.json();

// Ensure definition exists
            const definition = data[0]?.meanings?.[0]?.definitions?.[0]?.definition;
            return definition || "Definition not found.";
         } catch (error) {
            console.error("Error fetching definition:", error);
            return "Error fetching definition.";
         }
      }

// Detects if the word is German (de) or English (en)
      function detectLanguage(word) {
         const germanChars = /[äöüß]/; // Checks for special German letters
         const commonGermanWords = ["und", "das", "ist", "du", "nicht", "ein", "ich", "er", "sie"]; // Common German words

if (germanChars.test(word) || commonGermanWords.includes(word.toLowerCase())) {
            return "de"; // German
         }
         return "en"; // English (default)
      }

function createDictionaryModal(word, meaning) {
         // Remove existing modal before creating a new one
         let existingModal = document.getElementById("dictionaryModal");
         if (existingModal) existingModal.remove();

// Create modal container
         let modal = document.createElement("div");
         modal.id = "dictionaryModal";
         Object.assign(modal.style, {
            position: "fixed",
            top: "50%",
            left: "50%",
            transform: "translate(-50%, -50%)",
            width: "400px",
            backgroundColor: "#fff",
            boxShadow: "0px 4px 10px rgba(0,0,0,0.2)",
            borderRadius: "10px",
            padding: "20px",
            zIndex: "9999",
            fontFamily: "Arial, sans-serif",
            display: "flex",
            flexDirection: "column",
            alignItems: "center",
            textAlign: "center"
         });

// Close button (properly aligned)
         let closeButton = document.createElement("button");
         closeButton.innerHTML = "❌";
         Object.assign(closeButton.style, {
            position: "absolute",
            top: "8px",
            right: "8px",
            border: "none",
            background: "transparent",
            cursor: "pointer",
            fontSize: "18px"
         });
         closeButton.addEventListener("click", () => {
            modal.remove();
            clearTextSelection(); // Deselect text when modal closes
         });

// Definition text
         let definitionText = document.createElement("p");
         definitionText.innerHTML = `<strong>${word} (Definition):</strong> ${meaning}`;
         Object.assign(definitionText.style, {
            fontSize: "16px",
            marginBottom: "15px"
         });

// Create a container for buttons (side-by-side alignment)
         let buttonContainer = document.createElement("div");
         Object.assign(buttonContainer.style, {
            display: "flex",
            justifyContent: "center",
            gap: "10px",
            marginTop: "10px",
            width: "100%"
         });

// Read button (text-to-speech)
         let readButton = document.createElement("button");
         readButton.innerText = "🔊 Read";
         Object.assign(readButton.style, buttonStyle("#4A90E2"));
         readButton.addEventListener("click", () => {
            let speech = new SpeechSynthesisUtterance(word);
            speechSynthesis.speak(speech);
         });

// Spell button (letter-by-letter speech)
         let spellButton = document.createElement("button");
         spellButton.innerText = "🔤 Spell";
         Object.assign(spellButton.style, buttonStyle("#50C878"));
         spellButton.addEventListener("click", () => {
            let speech = new SpeechSynthesisUtterance(word.split("").join(" "));
            speechSynthesis.speak(speech);
         });

// Append buttons inside the container
         buttonContainer.appendChild(readButton);
         buttonContainer.appendChild(spellButton);

// Append elements to the modal
         modal.appendChild(closeButton);
         modal.appendChild(definitionText);
         modal.appendChild(buttonContainer);
         document.body.appendChild(modal);

// Make the modal draggable
         makeModalDraggable(modal);
      }

// Function to clear selected text
      function clearTextSelection() {
         if (window.getSelection) {
            window.getSelection().removeAllRanges();
         } else if (document.selection) {
            document.selection.empty();
         }
      }

// Utility function for button styles
      function buttonStyle(color) {
         return {
            background: color,
            color: "#fff",
            border: "none",
            padding: "10px 15px",
            borderRadius: "5px",
            cursor: "pointer",
            fontSize: "14px",
            minWidth: "80px",
            textAlign: "center"
         };
      }

function resetFontSize(element) {
         if (element.dataset.originalFontSize) {
            element.style.fontSize = element.dataset.originalFontSize;
         }
      }

function storeOriginalFontSize(element) {
         if (!element.dataset.originalFontSize) {
            element.dataset.originalFontSize = window.getComputedStyle(element).fontSize;
         }
      }

function applyFontSizeChange(multiplier) {
         applyStylesToDocumentExceptWidget((element) => {
            storeOriginalFontSize(element);
            resetFontSize(element);
            let originalSize = parseFloat(element.dataset.originalFontSize);
            let newSize = originalSize * multiplier + "px";
            element.style.transition = "all 0.3s ease";
            element.style.fontSize = newSize;
         });
      }

// Function to make the modal draggable
      function makeModalDraggable(modal) {
         let isDragging = false,
            offsetX, offsetY;

modal.addEventListener("mousedown", (e) => {
            isDragging = true;
            offsetX = e.clientX - modal.getBoundingClientRect().left;
            offsetY = e.clientY - modal.getBoundingClientRect().top;
            modal.style.cursor = "grabbing";
         });

document.addEventListener("mouseup", () => {
            isDragging = false;
            modal.style.cursor = "default";
         });
      }

// Dictionary Popup functions ends here

// Main Switch and Event Section
      switch (event.data.action || event.data) {

// content adjustment

case "CLOSE_MODAL":
               const modals = document.querySelectorAll(".modal-container");
               modals.forEach((modal) => {
                  modal.remove();
               });
               const hideInterfaceModal = document.getElementById("widget-hide-confirm-modal");
               if (hideInterfaceModal) {
                  hideInterfaceModal.remove();
               }
               break;

case "Highlight Links":
            document.querySelectorAll("a").forEach((link) => {
               if (link.style.backgroundColor === "black") {
                  link.style.removeProperty("background-color");
                  link.style.removeProperty("color");
                  link.style.removeProperty("text-decoration");

// Also reset button styles if <a> is inside a button
                  let parentButton = link.closest("button");
                  if (parentButton) {
                     parentButton.style.removeProperty("background-color");
                     parentButton.style.removeProperty("color");
                  }
               } else {
                  link.style.setProperty("background-color", "black", "important");
                  link.style.setProperty("color", "yellow", "important");
                  link.style.setProperty("text-decoration", "underline", "important");

// Apply black background to button if <a> is inside it
                  let parentButton = link.closest("button");
                  if (parentButton) {
                     parentButton.style.setProperty("background-color", "black", "important");
                     parentButton.style.setProperty("color", "yellow", "important");
                  }
               }
            });
            break;

// ✅ CASE: Align Center
         case "Align Center":
            (function () {
               document.querySelectorAll("body *:not(#widget-container, #widget-container *)").forEach((element) => {
                  element.style.textAlign = "center";
               });
            })();
            break;

// ✅ CASE: Unselect Align Center (Reset to Default)
         case "unselected:Align Center":
            (function () {
               document.querySelectorAll("body *:not(#widget-container, #widget-container *)").forEach((element) => {
                  element.style.textAlign = ""; // Reset to default
               });
            })();
            break;

// ✅ CASE: Align Left
         case "Align Left":
            (function () {
               document.querySelectorAll("body *:not(#widget-container, #widget-container *)").forEach((element) => {
                  element.style.textAlign = "left";
               });
            })();
            break;

// ✅ CASE: Unselect Align Left (Reset to Default)
         case "unselected:Align Left":
            (function () {
               document.querySelectorAll("body *:not(#widget-container, #widget-container *)").forEach((element) => {
                  element.style.textAlign = ""; // Reset to default
               });
            })();
            break;

// ✅ CASE: Align Right
         case "Align Right":
            (function () {
               document.querySelectorAll("body *:not(#widget-container, #widget-container *)").forEach((element) => {
                  element.style.textAlign = "right";
               });
            })();
            break;

// ✅ CASE: Unselect Align Right (Reset to Default)
         case "unselected:Align Right":
            (function () {
               document.querySelectorAll("body *:not(#widget-container, #widget-container *)").forEach((element) => {
                  element.style.textAlign = ""; // Reset to default
               });
            })();
            break;

case "Align Justify":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.textAlign = "justify";
            });
            break;

case "Bigger Text":
            applyFontSizeChange(1.1); // Increase by 20%
            break;

case "XL Bigger Text":
            applyFontSizeChange(1.2); // Increase by 40%
            break;

case "2 XL Bigger Text":
            // applyStylesToDocumentExceptWidget((element) => {
            //     let currentSize = window.getComputedStyle(element).fontSize;
            //     let newSize = parseFloat(currentSize) * 1.4 + "px"; // Increase by 40%
            //     element.style.transition = "all 0.3s ease";
            //     element.style.fontSize = newSize;
            // });
            applyFontSizeChange(1.4); // Increase by 60%
            break;

case "3 XL Bigger Text":
            applyFontSizeChange(1.6); // Increase by 60%
            break;

case "Heavy Space":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.letterSpacing = "0.36em";
               element.style.wordSpacing = "0.48em";
            });
            break;

case "Moderate Space":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.letterSpacing = "0.24em";
               element.style.wordSpacing = "0.32em";
            });
            break;

case "Light Space":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.letterSpacing = "0.12em";
               element.style.wordSpacing = "0.16em";
            });
            break;

case "Line Height(1.5x)":
            document.querySelectorAll("p, span, h1, h2, h3, h4, h5, h6, a, li").forEach((element) => {
               element.style.setProperty("line-height", "50px", "important");
            });
            break;

case "Line Height(1.75x)":
            document.querySelectorAll("p, span, h1, h2, h3, h4, h5, h6, a, li").forEach((element) => {
               element.style.setProperty("line-height", "70px", "important");
            });
            break;

case "Line Height(2x)":
            document.querySelectorAll("p, span, h1, h2, h3, h4, h5, h6, a, li").forEach((element) => {
               element.style.setProperty("line-height", "90px", "important");
            });
            break;

// ✅ CASE: Low Saturation (Inject CSS in <html>)
         case "Low Saturation":
            console.log("Applying Low Saturation");
            (function () {
               let existingStyle = document.getElementById("saturationStyle");
               if (existingStyle) existingStyle.remove();

let style = document.createElement("style");
               style.id = "saturationStyle";
               style.innerHTML = `
            html {
                filter: saturate(0.5) !important;
            }
            #widget-container, #widget-container * {
                filter: none !important; /* Ensure widget is unaffected */
            }
        `;
               document.head.appendChild(style);
            })();
            break;

// ✅ CASE: High Saturation (Inject CSS in <html>)
         case "High Saturation":
            console.log("Applying High Saturation");
            (function () {
               let existingStyle = document.getElementById("saturationStyle");
               if (existingStyle) existingStyle.remove();

let style = document.createElement("style");
               style.id = "saturationStyle";
               style.innerHTML = `
            html {
                filter: saturate(3) !important;
            }
            #widget-container, #widget-container * {
                filter: none !important; /* Ensure widget is unaffected */
            }
        `;
               document.head.appendChild(style);
            })();
            break;

// ✅ CASE: Desaturate (Inject CSS in <html>)
         case "Desaturate":
            console.log("Applying Desaturation");
            (function () {
               let existingStyle = document.getElementById("saturationStyle");
               if (existingStyle) existingStyle.remove();

let style = document.createElement("style");
               style.id = "saturationStyle";
               style.innerHTML = `
            html {
                filter: saturate(0) !important;
            }
            #widget-container, #widget-container * {
                filter: none !important; /* Ensure widget is unaffected */
            }
        `;
               document.head.appendChild(style);
            })();
            break;

// ✅ CASE: Unselect Saturation (Remove All Filters)
         case "unselected:Saturation":
            console.log("Removing Saturation Effects");
            (function () {
               let existingStyle = document.getElementById("saturationStyle");
               if (existingStyle) {
                  existingStyle.remove();
                  console.log("Saturation style removed");
               }
            })();
            break;

case "Change Background Color":
            document.documentElement.style.backgroundColor = event.data.color;
            document.body.style.backgroundColor = event.data.color;
            break;

case "Change Text Color":
            document.documentElement.style.color = event.data.color;
            document.body.style.color = event.data.color;
            const bodyElements = document.querySelectorAll("body *");
            bodyElements.forEach((element) => {
               element.style.color = event.data.color;
            });
            break;
         case "Smart Contrast":
            document.body.style.transition = "background 0.4s, color 0.4s, filter 0.4s";
            applyStylesToDocumentExceptWidget((element) => {
               if (window.getComputedStyle(element).display !== 'none' && element.innerText) {
                  element.style.backgroundColor = "#FFFFFF";
                  element.style.color = "#000000";
                  element.style.borderColor = "#000000";

if (element.tagName.toLowerCase() === 'a') {
                     element.style.color = "#0000EE";
                     element.style.textDecoration = "underline";
                  }

element.classList.add("smart-contrast-applied");
               }
            });

document.body.style.backgroundColor = "#FFFFFF";
            document.body.style.color = "#000000";
            break;

// blue filter missing

// end of color adjustment

// orientation adjustment
         case "Screen Reader":
            removeTextReadListeners();
            readerActivated = true;
            const welcomeText = isWebsiteGerman() ?
               "User Aid Sprachmodus ist jetzt im normalen Modus aktiviert." :
               "User Aid Screenreader is now activated in Normal mode.";
            readPageText(1, welcomeText, isWebsiteGerman() ? "de-DE" : "en-US");

document.addEventListener("click", (event) => handleTextRead(event, 1));
            break;

case "Read Fast":
            readerActivated = true;

removeTextReadListeners();
            const fastText = isWebsiteGerman() ?
               "User Aid Sprachmodus ist jetzt im schnellen Modus aktiviert." :
               "User Aid Screenreader is now activated in Fast mode.";

readPageText(2, fastText, isWebsiteGerman() ? "de-DE" : "en-US");

document.addEventListener("click", (event) => handleTextRead(event, 2));
            break;

case "Read Slow":
            readerActivated = true;
            removeTextReadListeners();
            const slowText = isWebsiteGerman() ?
               "User Aid Sprachmodus ist jetzt im langsamen Modus aktiviert." :
               "User Aid Screenreader is now activated in Slow mode.";
            readPageText(0.5, slowText, isWebsiteGerman() ? "de-DE" : "en-US");
            document.addEventListener("click", (event) => handleTextRead(event, 0.5));
            break;
         case "Mute Sound":
            if (window.speechSynthesis.speaking) {
               // Pause the speech synthesis instead of canceling it
               window.speechSynthesis.pause();
            }
            break;

// Add a style element for animations and responsive styles
            function addVoiceNavigationStyles() {
               const styleElement = document.createElement('style');
               styleElement.id = 'user-aid-voice-navigation-styles';
               styleElement.textContent = `
            @keyframes pulse {
                0% {
                    transform: scale(1);
                    box-shadow: 0 0 0 0 rgba(255, 74, 74, 0.7);
                }
                
                70% {
                    transform: scale(1.05);
                    box-shadow: 0 0 0 10px rgba(255, 74, 74, 0);
                }
                
                100% {
                    transform: scale(1);
                    box-shadow: 0 0 0 0 rgba(255, 74, 74, 0);
                }
            }
            
            .user-aid-number-label {
                transition: all 0.2s ease;
            }
            
            .user-aid-number-label:hover {
                transform: scale(1.2);
                box-shadow: 0 0 10px rgba(255, 255, 255, 0.5);
            }
            
            @media (max-width: 768px) {
                .user-aid-number-label {
                    width: 22px !important;
                    height: 22px !important;
                    font-size: 11px !important;
                }
                
                #user-aid-mic-icon {
                    width: 36px !important;
                    height: 36px !important;
                }
                
                #user-aid-toggle-commands {
                    width: 32px !important;
                    height: 32px !important;
                }
                
                #user-aid-status-text {
                    font-size: 14px !important;
                }
                
                #user-aid-help-text {
                    font-size: 12px !important;
                    display: none !important;
                }
                
                #user-aid-commands-panel {
                    padding: 10px 15px !important;
                }
            }
        `;
               document.head.appendChild(styleElement);
            }

// voice navigtation start from here

case "Voice Navigation":

console.log("✅ User Aid Voice Navigation activated", event.data.value);

// Check if already initialized to prevent multiple instances
            if (document.getElementById('user-aid-voice-navigation')) {
               console.log("User Aid Voice Navigation already active - not initializing again");
               return; // Exit to prevent multiple instances
            }

// Declare core variables
            let currentLanguage = 'en-US';
            let recognition = null;
            let isListening = false;
            let lastCommand = "";
            let recognitionTimeout = null;

// Map language code from event.data.value to speech recognition language code
            function mapLanguageCode(code) {
               const languageMap = {
                  'en': 'en-US',
                  'gr': 'de-DE', // German code is 'gr' in your system but 'de-DE' for speech recognition
                  'it': 'it-IT', // Italian
                  'fr': 'fr-FR', // French
                  'ru': 'ru-RU', // Russian
                  'nl': 'nl-NL', // Dutch
                  'tr': 'tr-TR', // Turkish
                  'pl': 'pl-PL', // Polish
                  'ar': 'ar-SA', // Arabic
                  'zh-Hans': 'zh-CN' // Simplified Chinese
               };

return languageMap[code] || 'en-US'; // Default to English if code not found
            }

// Function to detect the website language
            function detectWebsiteLanguage(selectedLang) {
               if (selectedLang) {
                  return mapLanguageCode(selectedLang);
               }

try {
                  // Check HTML lang attribute first
                  const htmlLang = document.documentElement.lang.toLowerCase();
                  if (htmlLang) {
                     if (htmlLang.startsWith('en')) return 'en-US';
                     if (htmlLang.startsWith('de')) return 'de-DE';
                     if (htmlLang.startsWith('it')) return 'it-IT';
                     if (htmlLang.startsWith('fr')) return 'fr-FR';
                     if (htmlLang.startsWith('ru')) return 'ru-RU';
                     if (htmlLang.startsWith('nl')) return 'nl-NL';
                     if (htmlLang.startsWith('tr')) return 'tr-TR';
                     if (htmlLang.startsWith('pl')) return 'pl-PL';
                     if (htmlLang.startsWith('ar')) return 'ar-SA';
                     if (htmlLang.startsWith('zh')) return 'zh-CN';
                  }
               } catch (error) {
                  console.error("Error detecting language:", error);
               }

// Default to English
               return 'en-US';
            }

// Get UI text based on language
            function getUIText(language) {
               const texts = {
                  'en-US': {
                     title: 'User Aid is listening',
                     startPrompt: 'Click microphone to start voice navigation',
                     listening: 'User Aid is listening',
                     helpCommand: 'Available voice commands:',
                     showNumbersCommand: 'Show numbers command:',
                     scrollCommand: 'Scroll commands:',
                     lastCommand: 'Last command:',
                     recognized: 'Recognized speech:',
                     helpMe: 'Help me',
                     showCommands: 'Show Commands',
                     showNumbers: 'Show Numbers',
                     displayNumbers: 'Display Numbers',
                     hideNumbers: 'Hide Numbers',
                     scrollDown: 'Scroll Down',
                     scrollUp: 'Scroll Up',
                     pageDown: 'Page Down',
                     pageUp: 'Page Up',
                     error: "No speech detected",
                     sayHelp: "Say \"Help\" to see all available commands"
                  },
                  'de-DE': {
                     title: 'User Aid hört zu',
                     startPrompt: 'Klicken Sie auf das Mikrofon, um die Sprachnavigation zu starten',
                     listening: 'User Aid hört zu',
                     helpCommand: 'Verfügbare Sprachbefehle:',
                     showNumbersCommand: 'Zahlen anzeigen Befehl:',
                     scrollCommand: 'Scroll-Befehle:',
                     lastCommand: 'Letzter Befehl:',
                     recognized: 'Erkannte Sprache:',
                     helpMe: 'Hilfe',
                     showCommands: 'Befehle anzeigen',
                     showNumbers: 'Zahlen anzeigen',
                     displayNumbers: 'Nummern anzeigen',
                     hideNumbers: 'Nummern verstecken',
                     scrollDown: 'Nach unten scrollen',
                     scrollUp: 'Nach oben scrollen',
                     pageDown: 'Seite runter',
                     pageUp: 'Seite hoch',
                     error: "Keine Sprache erkannt",
                     sayHelp: "Sagen Sie \"Hilfe\", um alle verfügbaren Befehle zu sehen"
                  },
                  'it-IT': {
                     title: 'User Aid è in ascolto',
                     startPrompt: 'Clicca sul microfono per avviare la navigazione vocale',
                     listening: 'User Aid è in ascolto',
                     helpCommand: 'Comandi vocali disponibili:',
                     showNumbersCommand: 'Comando mostra numeri:',
                     scrollCommand: 'Comandi di scorrimento:',
                     lastCommand: 'Ultimo comando:',
                     recognized: 'Discorso riconosciuto:',
                     helpMe: 'Aiutami',
                     showCommands: 'Mostra comandi',
                     showNumbers: 'Mostra numeri',
                     displayNumbers: 'Visualizza numeri',
                     hideNumbers: 'Nascondi numeri',
                     scrollDown: 'Scorri giù',
                     scrollUp: 'Scorri su',
                     pageDown: 'Pagina giù',
                     pageUp: 'Pagina su',
                     error: "Nessun discorso rilevato",
                     sayHelp: "Dì \"Aiutami\" per vedere tutti i comandi disponibili"
                  },
                  'fr-FR': {
                     title: 'User Aid écoute',
                     startPrompt: 'Cliquez sur le microphone pour démarrer la navigation vocale',
                     listening: 'User Aid écoute',
                     helpCommand: 'Commandes vocales disponibles:',
                     showNumbersCommand: 'Commande pour afficher les numéros:',
                     scrollCommand: 'Commandes de défilement:',
                     lastCommand: 'Dernière commande:',
                     recognized: 'Discours reconnu:',
                     helpMe: 'Aide-moi',
                     showCommands: 'Afficher les commandes',
                     showNumbers: 'Afficher les numéros',
                     displayNumbers: 'Montrer les numéros',
                     hideNumbers: 'Cacher les numéros',
                     scrollDown: 'Défiler vers le bas',
                     scrollUp: 'Défiler vers le haut',
                     pageDown: 'Page suivante',
                     pageUp: 'Page précédente',
                     error: "Aucune parole détectée",
                     sayHelp: "Dites \"Aide-moi\" pour voir toutes les commandes disponibles"
                  },
                  'ru-RU': {
                     title: 'User Aid слушает',
                     startPrompt: 'Нажмите на микрофон, чтобы начать голосовую навигацию',
                     listening: 'User Aid слушает',
                     helpCommand: 'Доступные голосовые команды:',
                     showNumbersCommand: 'Команда показать номера:',
                     scrollCommand: 'Команды прокрутки:',
                     lastCommand: 'Последняя команда:',
                     recognized: 'Распознанная речь:',
                     helpMe: 'Помоги мне',
                     showCommands: 'Показать команды',
                     showNumbers: 'Показать номера',
                     displayNumbers: 'Отобразить номера',
                     hideNumbers: 'Скрыть номера',
                     scrollDown: 'Прокрутить вниз',
                     scrollUp: 'Прокрутить вверх',
                     pageDown: 'Страница вниз',
                     pageUp: 'Страница вверх',
                     error: "Речь не обнаружена",
                     sayHelp: "Скажите \"Помоги мне\", чтобы увидеть все доступные команды"
                  },
                  'nl-NL': {
                     title: 'User Aid luistert',
                     startPrompt: 'Klik op de microfoon om spraaknavigatie te starten',
                     listening: 'User Aid luistert',
                     helpCommand: 'Beschikbare spraakopdrachten:',
                     showNumbersCommand: 'Toon nummers opdracht:',
                     scrollCommand: 'Scrol opdrachten:',
                     lastCommand: 'Laatste opdracht:',
                     recognized: 'Herkende spraak:',
                     helpMe: 'Help me',
                     showCommands: 'Toon opdrachten',
                     showNumbers: 'Toon nummers',
                     displayNumbers: 'Geef nummers weer',
                     hideNumbers: 'Verberg nummers',
                     scrollDown: 'Scroll omlaag',
                     scrollUp: 'Scroll omhoog',
                     pageDown: 'Pagina omlaag',
                     pageUp: 'Pagina omhoog',
                     error: "Geen spraak gedetecteerd",
                     sayHelp: "Zeg \"Help me\" om alle beschikbare opdrachten te zien"
                  },
                  'tr-TR': {
                     title: 'User Aid dinliyor',
                     startPrompt: 'Sesli navigasyonu başlatmak için mikrofona tıklayın',
                     listening: 'User Aid dinliyor',
                     helpCommand: 'Kullanılabilir ses komutları:',
                     showNumbersCommand: 'Numaraları göster komutu:',
                     scrollCommand: 'Kaydırma komutları:',
                     lastCommand: 'Son komut:',
                     recognized: 'Tanınan konuşma:',
                     helpMe: 'Bana yardım et',
                     showCommands: 'Komutları göster',
                     showNumbers: 'Numaraları göster',
                     displayNumbers: 'Numaraları görüntüle',
                     hideNumbers: 'Numaraları gizle',
                     scrollDown: 'Aşağı kaydır',
                     scrollUp: 'Yukarı kaydır',
                     pageDown: 'Sayfa aşağı',
                     pageUp: 'Sayfa yukarı',
                     error: "Konuşma algılanmadı",
                     sayHelp: "Tüm mevcut komutları görmek için \"Bana yardım et\" deyin"
                  },
                  'pl-PL': {
                     title: 'User Aid słucha',
                     startPrompt: 'Kliknij mikrofon, aby rozpocząć nawigację głosową',
                     listening: 'User Aid słucha',
                     helpCommand: 'Dostępne komendy głosowe:',
                     showNumbersCommand: 'Komenda pokaż numery:',
                     scrollCommand: 'Komendy przewijania:',
                     lastCommand: 'Ostatnia komenda:',
                     recognized: 'Rozpoznana mowa:',
                     helpMe: 'Pomóż mi',
                     showCommands: 'Pokaż komendy',
                     showNumbers: 'Pokaż numery',
                     displayNumbers: 'Wyświetl numery',
                     hideNumbers: 'Ukryj numery',
                     scrollDown: 'Przewiń w dół',
                     scrollUp: 'Przewiń w górę',
                     pageDown: 'Strona w dół',
                     pageUp: 'Strona w górę',
                     error: "Nie wykryto mowy",
                     sayHelp: "Powiedz \"Pomóż mi\", aby zobaczyć wszystkie dostępne komendy"
                  },
                  'ar-SA': {
                     title: 'User Aid يستمع',
                     startPrompt: 'انقر على الميكروفون لبدء التنقل الصوتي',
                     listening: 'User Aid يستمع',
                     helpCommand: 'الأوامر الصوتية المتاحة:',
                     showNumbersCommand: 'أمر إظهار الأرقام:',
                     scrollCommand: 'أوامر التمرير:',
                     lastCommand: 'الأمر الأخير:',
                     recognized: 'الكلام المتعرف عليه:',
                     helpMe: 'ساعدني',
                     showCommands: 'إظهار الأوامر',
                     showNumbers: 'إظهار الأرقام',
                     displayNumbers: 'عرض الأرقام',
                     hideNumbers: 'إخفاء الأرقام',
                     scrollDown: 'تمرير للأسفل',
                     scrollUp: 'تمرير للأعلى',
                     pageDown: 'صفحة للأسفل',
                     pageUp: 'صفحة للأعلى',
                     error: "لم يتم اكتشاف كلام",
                     sayHelp: "قل \"ساعدني\" لرؤية جميع الأوامر المتاحة"
                  },
                  'zh-CN': {
                     title: 'User Aid \u6B63\u5728\u804A\u542C',
                     startPrompt: '\u70B9\u51FB\u9EA6\u514B\u98CE\u5F00\u59CB\u8BED\u97F3\u5BFC\u822A',
                     listening: 'User Aid \u6B63\u5728\u804A\u542C',
                     helpCommand: '\u53EF\u7528\u8BED\u97F3\u547D\u4EE4:',
                     showNumbersCommand: '\u663E\u793A\u6570\u5B57\u547D\u4EE4:',
                     scrollCommand: '\u6EDA\u52A8\u547D\u4EE4:',
                     lastCommand: '\u4E0A\u4E00\u4E2A\u547D\u4EE4:',
                     recognized: '\u8BC6\u522B\u5230\u7684\u8BED\u97F3:',
                     helpMe: '\u5E2E\u52A9\u6211',
                     showCommands: '\u663E\u793A\u547D\u4EE4',
                     showNumbers: '\u663E\u793A\u6570\u5B57',
                     displayNumbers: '\u5C55\u793A\u6570\u5B57',
                     hideNumbers: '\u9690\u85CF\u6570\u5B57',
                     scrollDown: '\u5411\u4E0B\u6EDA\u52A8',
                     scrollUp: '\u5411\u4E0A\u6EDA\u52A8',
                     pageDown: '\u5411\u4E0B\u7FFB\u9875',
                     pageUp: '\u5411\u4E0A\u7FFB\u9875',
                     error: "\u672A\u68C0\u6D4B\u5230\u8BED\u97F3",
                     sayHelp: "\u8BF4\"\u5E2E\u52A9\u6211\"\u4EE5\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4"
                  }
               };

return texts[language] || texts['en-US']; // Default to English if language not found
            }

// Create the voice navigation UI
            function createVoiceNavigationUI() {
               // Detect language and get text
               currentLanguage = detectWebsiteLanguage(event.data.value);
               console.log("Setting voice navigation language to:", currentLanguage);

const uiText = getUIText(currentLanguage);

// Create main container
               const container = document.createElement('div');
               container.id = 'user-aid-voice-navigation';
               container.style.cssText = `
            position: fixed;
            bottom: 20px;
            left: 50%;
            transform: translateX(-50%);
            z-index: 99999;
            font-family: Arial, sans-serif;
            max-width: 600px;
            width: 90%;
        `;

// Add responsive styles based on screen size
               if (window.innerWidth <= 768) {
                  container.style.width = '95%';
                  container.style.maxWidth = 'none';
                  container.style.bottom = '10px';
               }

// Create the main panel
               const panel = document.createElement('div');
               panel.style.cssText = `
            background-color: rgba(51, 51, 51, 0.85);
            backdrop-filter: blur(5px);
            -webkit-backdrop-filter: blur(5px);
            width: 100%;
            border-radius: 30px;
            overflow: hidden;
            color: white;
            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.25);
            max-height: 90vh;
            overflow-y: auto;
            position: relative;
            border: 1px solid rgba(255, 255, 255, 0.1);
            display: flex;
            align-items: center;
            padding: 15px 20px;
        `;

// Microphone icon
               const micIcon = document.createElement('div');
               micIcon.id = 'user-aid-mic-icon';
               micIcon.style.cssText = `
            width: 40px;
            height: 40px;
            border-radius: 50%;
            background-color: #4a86ff;
            display: flex;
            align-items: center;
            justify-content: center;
            margin-right: 15px;
            cursor: pointer;
            flex-shrink: 0;
        `;
               micIcon.innerHTML = `<svg width="20" height="20" viewBox="0 0 24 24" fill="white">
            <path d="M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3z"></path>
            <path d="M17 11c0 2.76-2.24 5-5 5s-5-2.24-5-5H5c0 3.53 2.61 6.43 6 6.92V21h2v-3.08c3.39-.49 6-3.39 6-6.92h-2z"></path>
        </svg>`;

// Add click event to microphone icon
               micIcon.addEventListener('click', toggleSpeechRecognition);

// Status text
               const statusText = document.createElement('span');
               statusText.id = 'user-aid-status-text';
               statusText.textContent = uiText.title;
               statusText.style.cssText = `
            font-size: 16px;
            font-weight: 500;
            flex-grow: 1;
        `;

// Help text
               const helpText = document.createElement('span');
               helpText.id = 'user-aid-help-text';
               helpText.textContent = uiText.sayHelp;
               helpText.style.cssText = `
            font-size: 14px;
            color: #cccccc;
            margin-right: 15px;
            display: none;
        `;

// Toggle commands button
               const toggleButton = document.createElement('button');
               toggleButton.id = 'user-aid-toggle-commands';
               toggleButton.style.cssText = `
            background-color: #4a86ff;
            border: none;
            width: 36px;
            height: 36px;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            cursor: pointer;
            margin-right: 10px;
            flex-shrink: 0;
        `;
               toggleButton.innerHTML = `<svg width="18" height="18" viewBox="0 0 24 24" fill="white">
            <path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"></path>
        </svg>`;

toggleButton.addEventListener('click', () => {
                  const commandsPanel = document.getElementById('user-aid-commands-panel');
                  const helpText = document.getElementById('user-aid-help-text');
                  const isExpanded = toggleButton.getAttribute('data-expanded') === 'true';

if (isExpanded) {
                     // Collapse
                     if (commandsPanel) commandsPanel.style.display = 'none';
                     if (helpText) helpText.style.display = 'inline';
                     toggleButton.innerHTML = `<svg width="18" height="18" viewBox="0 0 24 24" fill="white">
                    <path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"></path>
                </svg>`;
                     toggleButton.setAttribute('data-expanded', 'false');
                  } else {
                     // Expand
                     if (commandsPanel) commandsPanel.style.display = 'block';
                     if (helpText) helpText.style.display = 'none';
                     toggleButton.innerHTML = `<svg width="18" height="18" viewBox="0 0 24 24" fill="white">
                    <path d="M19 13H5v-2h14v2z"></path>
                </svg>`;
                     toggleButton.setAttribute('data-expanded', 'true');
                  }
               });
               toggleButton.setAttribute('data-expanded', 'false');

// Close button
               const closeButton = document.createElement('button');
               closeButton.style.cssText = `
            background: transparent;
            border: none;
            color: white;
            font-size: 22px;
            cursor: pointer;
            display: flex;
            align-items: center;
            justify-content: center;
            width: 28px;
            height: 28px;
            padding: 0;
            flex-shrink: 0;
        `;
               closeButton.innerHTML = `<svg width="16" height="16" viewBox="0 0 24 24" fill="white">
            <path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path>
        </svg>`;

closeButton.addEventListener('click', () => {
                  // Stop speech recognition if running
                  stopSpeechRecognition();

// Remove UI
                  container.remove();

// Remove number labels
                  removeNumberLabels();

// Remove event listeners
                  window.removeEventListener('resize', handleResize);
                  window.removeEventListener('scroll', handleScroll);

// Clear any existing timeouts
                  if (window.scrollUpdateTimeout) {
                     clearTimeout(window.scrollUpdateTimeout);
                  }

// Reset variables
                  isListening = false;
                  recognition = null;

console.log("User Aid Voice Navigation completely disabled");
               });

// Add elements to panel
               panel.appendChild(micIcon);
               panel.appendChild(statusText);
               panel.appendChild(helpText);
               panel.appendChild(toggleButton);
               panel.appendChild(closeButton);

// Create commands panel (initially hidden)
               const commandsPanel = document.createElement('div');
               commandsPanel.id = 'user-aid-commands-panel';
               commandsPanel.style.cssText = `
            background-color: rgba(51, 51, 51, 0.85);
            backdrop-filter: blur(5px);
            -webkit-backdrop-filter: blur(5px);
            border-top: 1px solid rgba(255, 255, 255, 0.1);
            padding: 15px 20px;
            margin-top: 10px;
            display: none;
            border-radius: 20px;
        `;

// Add recognized speech display
               const recognizedSpeech = document.createElement('div');
               recognizedSpeech.id = 'user-aid-recognized-speech';
               recognizedSpeech.style.cssText = `
            margin-bottom: 15px;
            padding-bottom: 15px;
            border-bottom: 1px solid #444444;
        `;
               recognizedSpeech.innerHTML = `<span style="color: #aaaaaa; margin-right: 5px;">${uiText.recognized}</span><span id="speech-text"></span>`;

// Create commands section
               const commandsSection = document.createElement('div');
               commandsSection.id = 'user-aid-commands-section';

// Function to create command groups
               function createCommandSection(title, commands) {
                  const section = document.createElement('div');
                  section.style.cssText = `
                margin-bottom: 15px;
            `;

const sectionTitle = document.createElement('h3');
                  sectionTitle.textContent = title;
                  sectionTitle.style.cssText = `
                font-size: 14px;
                margin: 0 0 8px 0;
                color: #aaaaaa;
                font-weight: 500;
            `;

const commandsContainer = document.createElement('div');
                  commandsContainer.style.cssText = `
                display: flex;
                flex-wrap: wrap;
                gap: 8px;
            `;

commands.forEach(cmd => {
                     const button = document.createElement('button');
                     button.textContent = cmd;
                     button.style.cssText = `
                    background-color: #444444;
                    color: white;
                    border: 1px solid #555555;
                    border-radius: 20px;
                    padding: 6px 15px;
                    font-size: 13px;
                    cursor: pointer;
                    transition: background-color 0.2s;
                `;

button.addEventListener('mouseenter', () => {
                        button.style.backgroundColor = '#555555';
                     });

button.addEventListener('mouseleave', () => {
                        button.style.backgroundColor = '#444444';
                     });

if (cmd === uiText.showNumbers || cmd === uiText.displayNumbers) {
                        button.addEventListener('click', () => {
                           addNumberLabels();
                        });
                     } else if (cmd === uiText.hideNumbers) {
                        button.addEventListener('click', () => {
                           removeNumberLabels();
                        });
                     }

commandsContainer.appendChild(button);
                  });

section.appendChild(sectionTitle);
                  section.appendChild(commandsContainer);
                  return section;
               }

// Add command sections
               commandsSection.appendChild(createCommandSection(
                  uiText.helpCommand,
                  [uiText.helpMe, uiText.showCommands]
               ));

commandsSection.appendChild(createCommandSection(
                  uiText.showNumbersCommand,
                  [uiText.showNumbers, uiText.displayNumbers, uiText.hideNumbers]
               ));

commandsSection.appendChild(createCommandSection(
                  uiText.scrollCommand,
                  [uiText.scrollDown, uiText.scrollUp, uiText.pageDown, uiText.pageUp]
               ));

// Last command display
               const lastCommandContainer = document.createElement('div');
               lastCommandContainer.style.cssText = `
            margin-top: 15px;
            padding-top: 15px;
            border-top: 1px solid #444444;
        `;

const lastCommandText = document.createElement('div');
               lastCommandText.id = 'user-aid-last-command';
               lastCommandText.style.cssText = `
            font-size: 13px;
            color: #aaaaaa;
        `;
               lastCommandText.textContent = uiText.lastCommand;

lastCommandContainer.appendChild(lastCommandText);

// Add content to commands panel
               commandsPanel.appendChild(recognizedSpeech);
               commandsPanel.appendChild(commandsSection);
               commandsPanel.appendChild(lastCommandContainer);

// Add panel and commands panel to container
               container.appendChild(panel);
               container.appendChild(commandsPanel);

document.body.appendChild(container);

return container;
            }

// Toggle speech recognition on/off
            function toggleSpeechRecognition() {
               if (isListening) {
                  stopSpeechRecognition();
               } else {
                  startSpeechRecognition();
               }
            }

// Start speech recognition
            function startSpeechRecognition() {
               if (!window.SpeechRecognition && !window.webkitSpeechRecognition) {
                  console.warn("SpeechRecognition not supported by this browser");
                  alert("Voice recognition is not supported by your browser");
                  return;
               }

const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
               recognition = new SpeechRecognition();

// Configure recognition
               recognition.lang = currentLanguage;
               recognition.continuous = true;
               recognition.interimResults = true;
               recognition.maxAlternatives = 3; // Get multiple alternatives to improve accuracy

// Set recognition as active
               isListening = true;
               updateMicrophoneStatus(true);

// Add visual feedback during speech recognition
               const micIcon = document.getElementById('user-aid-mic-icon');
               if (micIcon) {
                  micIcon.classList.add('listening');
                  // Add pulsing animation
                  micIcon.style.animation = 'pulse 1.5s infinite';
               }

// Handle interim results
               recognition.onresult = function (event) {
                  for (let i = event.resultIndex; i < event.results.length; i++) {
                     const transcript = event.results[i][0].transcript.trim();
                     const isFinal = event.results[i].isFinal;

// Update the speech text display
                     updateSpeechText(transcript);

// Process final results
                     if (isFinal) {
                        console.log("Voice command detected:", transcript);
                        const processed = processVoiceCommand(transcript.toLowerCase());

// If command was successfully processed
                        if (processed) {
                           // Provide visual feedback of successful command
                           const statusText = document.getElementById('user-aid-status-text');
                           if (statusText) {
                              const originalText = statusText.textContent;
                              statusText.textContent = "Command recognized!";
                              setTimeout(() => {
                                 statusText.textContent = originalText;
                              }, 1500);
                           }
                        }

updateLastCommand(transcript);
                     }
                  }
               };

// Handle errors
               recognition.onerror = function (event) {
                  console.error("Speech recognition error:", event.error);
                  if (event.error === 'no-speech') {
                     updateMicrophoneStatus(false, getUIText(currentLanguage).error);
                  }
               };

// Restart if ended
               recognition.onend = function () {
                  if (isListening) {
                     try {
                        recognition.start();
                     } catch (e) {
                        console.error("Error restarting speech recognition:", e);
                        isListening = false;
                        updateMicrophoneStatus(false);
                     }
                  }
               };

// Start listening
               try {
                  recognition.start();
                  console.log("Speech recognition started");
               } catch (e) {
                  console.error("Error starting speech recognition:", e);
               }
            }

// Update the displayed speech text
            function updateSpeechText(text) {
               const speechText = document.getElementById('speech-text');
               if (speechText) {
                  speechText.textContent = text;
               }
            }

// Stop speech recognition
            function stopSpeechRecognition() {
               if (recognition) {
                  recognition.stop();
                  isListening = false;
                  updateMicrophoneStatus(false);
                  console.log("Speech recognition stopped");
               }
            }

// Update microphone status in UI
            function updateMicrophoneStatus(isActive, message) {
               const micIcon = document.getElementById('user-aid-mic-icon');
               const statusText = document.getElementById('user-aid-status-text');

if (micIcon) {
                  micIcon.style.backgroundColor = isActive ? '#ff4a4a' : '#4a86ff';
                  // Remove animation when not listening
                  if (!isActive) {
                     micIcon.style.animation = 'none';
                  }
               }

if (statusText) {
                  statusText.textContent = message || (isActive ?
                     getUIText(currentLanguage).listening :
                     getUIText(currentLanguage).title);
               }
            }

// Update last command display
            function updateLastCommand(command) {
               const lastCommandElement = document.getElementById('user-aid-last-command');
               if (lastCommandElement) {
                  lastCommandElement.textContent = `${getUIText(currentLanguage).lastCommand} "${command}"`;
               }
            }

// Process voice commands
            function processVoiceCommand(command) {
               console.log("Processing command: ", command);

// Get UI text for current language to match commands
               const uiText = getUIText(currentLanguage);

// Handle "show numbers" command
               if (command.includes(uiText.showNumbers.toLowerCase()) ||
                  command.includes(uiText.displayNumbers.toLowerCase())) {
                  addNumberLabels();
                  return true;
               }

// Handle "click [number]" command
               // Extract the number from the command
               const numberMatch = command.match(/\d+/);
               if (numberMatch) {
                  const number = parseInt(numberMatch[0]);
                  clickElementByNumber(number);
                  // Don't remove number labels after clicking
                  return true;
               }

// Handle direct number input (just saying a number)
               const directNumberMatch = /^(\d+)$/.exec(command);
               if (directNumberMatch) {
                  const number = parseInt(directNumberMatch[1]);
                  clickElementByNumber(number);
                  return true;
               }

// Handle scroll down command
               if (command.includes(uiText.scrollDown.toLowerCase()) ||
                  command.includes(uiText.pageDown.toLowerCase())) {
                  window.scrollBy({
                     top: window.innerHeight * 0.7,
                     behavior: 'smooth'
                  });
                  // Refresh number labels after scrolling
                  setTimeout(addNumberLabels, 600);
                  return true;
               }

// Handle scroll up command
               if (command.includes(uiText.scrollUp.toLowerCase()) ||
                  command.includes(uiText.pageUp.toLowerCase())) {
                  window.scrollBy({
                     top: -window.innerHeight * 0.7,
                     behavior: 'smooth'
                  });
                  // Refresh number labels after scrolling
                  setTimeout(addNumberLabels, 600);
                  return true;
               }

// Handle help command
               if (command.includes(uiText.helpMe.toLowerCase()) ||
                  command.includes(uiText.showCommands.toLowerCase())) {
                  // Show commands section
                  toggleCommandsSection(true);

// Expand the panel
                  const toggleButton = document.getElementById('user-aid-toggle-commands');
                  if (toggleButton) {
                     toggleButton.click();
                  }

return true;
               }

// Handle hide numbers command
               if (command.includes(uiText.hideNumbers.toLowerCase())) {
                  removeNumberLabels();
                  return true;
               }

console.log("No matching command found for: ", command);
               return false;
            }

// Toggle commands section visibility
            function toggleCommandsSection(show) {
               const commandsSection = document.getElementById('user-aid-commands-section');
               if (commandsSection) {
                  commandsSection.style.display = show ? 'block' : 'none';
               }
            }

// Click element by number
            function clickElementByNumber(number) {
               console.log(`Trying to click element number ${number}`);
               const element = document.querySelector(`[data-voice-number="${number}"]`);

if (element) {
                  console.log(`Found element with number ${number}, clicking...`);
                  clickElement(element);

// Keep numbers visible after clicking
                  setTimeout(() => {
                     // Refresh number labels
                     addNumberLabels();
                  }, 500);

return true;
               } else {
                  console.warn(`No element found with number ${number}`);
                  return false;
               }
            }

// Remove existing number labels
            function removeNumberLabels() {
               document.querySelectorAll('.user-aid-number-label').forEach(label => label.remove());
            }

// Add number labels to all clickable elements
            function addNumberLabels() {
               // Remove existing labels first
               removeNumberLabels();

// Get all clickable elements
               const elements = getClickableElements();

// Add a number label to each element
               let numberCount = 0;
               elements.forEach((element) => {
                  // Skip if the element is part of our voice navigation widget
                  if (element.closest('#user-aid-voice-navigation')) {
                     return;
                  }

createNumberLabel(element, numberCount + 1);

// Store element reference
                  element.dataset.voiceNumber = numberCount + 1;
                  numberCount++;
               });

console.log(`Added ${numberCount} number labels`);
            }

// Handle scroll event to update number labels
            function handleScroll() {
               // Use debounce to avoid too many updates
               if (window.scrollUpdateTimeout) {
                  clearTimeout(window.scrollUpdateTimeout);
               }

window.scrollUpdateTimeout = setTimeout(function () {
                  // Only update if numbers are currently shown
                  if (document.querySelectorAll('.user-aid-number-label').length > 0) {
                     addNumberLabels();
                  }
               }, 300);
            }

// Get all clickable elements on the page
            function getClickableElements() {
               const elements = [];

// Get all <a> tags with href attributes
               collectElements("a[href]", elements);

// Get all <button> elements that aren't disabled
               collectElements("button:not([disabled])", elements);

// Get form submit and button inputs that aren't disabled
               collectElements("input[type='submit']:not([disabled]), input[type='button']:not([disabled])", elements);

// Get elements with onclick attributes
               collectElements("*[onclick]", elements);

// Get elements with role="button"
               collectElements("*[role='button']", elements);

// Filter out any elements that are part of our voice navigation widget
               return elements.filter(element => !element.closest('#user-aid-voice-navigation'));
            }

// Collect valid elements
            function collectElements(selector, elements) {
               document.querySelectorAll(selector).forEach(element => {
                  // Skip if already collected
                  if (elements.includes(element)) return;

// Skip if not visible or clickable
                  if (!isVisibleAndClickable(element)) return;

elements.push(element);
               });
            }

// Check if element is visible and clickable
            function isVisibleAndClickable(element) {
               // Get computed style
               const style = window.getComputedStyle(element);

// Check if element is hidden
               if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
                  return false;
               }

// Check if element has dimensions
               const rect = element.getBoundingClientRect();
               if (rect.width <= 1 || rect.height <= 1) {
                  return false;
               }

// Check if element is in viewport
               if (rect.bottom < 0 || rect.right < 0 ||
                  rect.top > window.innerHeight || rect.left > window.innerWidth) {
                  return false;
               }

return true;
            }

// Create a number label for an element
            function createNumberLabel(element, number) {
               const rect = element.getBoundingClientRect();

// Create the label element
               const label = document.createElement('div');
               label.className = 'user-aid-number-label';
               label.textContent = number;
               label.style.cssText = `
            position: absolute;
            left: ${window.pageXOffset + rect.left + (rect.width/2) - 12}px;
            top: ${window.pageYOffset + rect.top + (rect.height/2) - 12}px;
            background-color: #000000;
            color: white;
            width: 24px;
            height: 24px;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 12px;
            font-weight: bold;
            font-family: Arial, sans-serif;
            z-index: 99999;
            cursor: pointer;
            box-shadow: 0 1px 3px rgba(0,0,0,0.2);
        `;

// Add click handler
               label.addEventListener('click', () => {
                  clickElement(element);
               });

document.body.appendChild(label);
            }

// Click the element
            function clickElement(element) {
               // Highlight effect
               const originalBackground = element.style.backgroundColor;
               element.style.backgroundColor = 'rgba(0, 0, 0, 0.1)';

// Scroll if needed
               if (!isInViewport(element)) {
                  element.scrollIntoView({
                     behavior: 'smooth',
                     block: 'center'
                  });

// Wait for scroll then click
                  setTimeout(() => {
                     element.click();
                     setTimeout(() => {
                        element.style.backgroundColor = originalBackground;
                        // Keep the numbers visible after clicking
                        setTimeout(addNumberLabels, 200);
                     }, 300);
                  }, 400);
               } else {
                  // Click immediately
                  element.click();
                  setTimeout(() => {
                     element.style.backgroundColor = originalBackground;
                     // Keep the numbers visible after clicking
                     setTimeout(addNumberLabels, 200);
                  }, 300);
               }
            }

// Check if element is in viewport
            function isInViewport(element) {
               const rect = element.getBoundingClientRect();
               return (
                  rect.top >= 0 &&
                  rect.left >= 0 &&
                  rect.bottom <= window.innerHeight &&
                  rect.right <= window.innerWidth
               );
            }

// Add styles for voice navigation
            function addVoiceNavigationStyles() {
               const style = document.createElement('style');
               style.textContent = `
            @keyframes pulse {
                0% {
                    transform: scale(1);
                    box-shadow: 0 0 0 0 rgba(255, 74, 74, 0.7);
                }
                
                70% {
                    transform: scale(1.05);
                    box-shadow: 0 0 0 10px rgba(255, 74, 74, 0);
                }
                
                100% {
                    transform: scale(1);
                    box-shadow: 0 0 0 0 rgba(255, 74, 74, 0);
                }
            }
            
            .user-aid-number-label {
                animation: fadeIn 0.3s ease-in-out;
            }
            
            @keyframes fadeIn {
                from {
                    opacity: 0;
                    transform: scale(0.8);
                }
                to {
                    opacity: 1;
                    transform: scale(1);
                }
            }
        `;
               document.head.appendChild(style);
            }

// Request microphone permission directly and initialize
            if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
               // Add styles first
               addVoiceNavigationStyles();

navigator.mediaDevices.getUserMedia({
                     audio: true
                  })
                  .then(function (stream) {
                     // Stop the stream immediately, we just needed permission
                     stream.getTracks().forEach(track => track.stop());
                     // Create the UI and start speech recognition
                     createVoiceNavigationUI();
                     // Start with collapsed UI by default
                     const toggleButton = document.getElementById('user-aid-toggle-commands');
                     if (toggleButton) {
                        toggleButton.setAttribute('data-expanded', 'false');
                     }
                     setTimeout(addNumberLabels, 500);
                     startSpeechRecognition();

// Add resize listener for responsiveness
                     window.addEventListener('resize', handleResize);
                     // Add scroll event listener
                     window.addEventListener('scroll', handleScroll);
                  })
                  .catch(function (err) {
                     console.error("Microphone permission denied:", err);
                     // If browser permission is denied, still create the UI but don't start recognition
                     createVoiceNavigationUI();
                     // Start with collapsed UI by default
                     const toggleButton = document.getElementById('user-aid-toggle-commands');
                     if (toggleButton) {
                        toggleButton.setAttribute('data-expanded', 'false');
                     }
                     setTimeout(addNumberLabels, 500);

// Add resize listener for responsiveness
                     window.addEventListener('resize', handleResize);
                     // Add scroll event listener
                     window.addEventListener('scroll', handleScroll);
                  });
            } else {
               console.warn("getUserMedia not supported by this browser");
               // Still create UI but don't start speech recognition
               addVoiceNavigationStyles();
               createVoiceNavigationUI();
               // Start with collapsed UI by default
               const toggleButton = document.getElementById('user-aid-toggle-commands');
               if (toggleButton) {
                  toggleButton.setAttribute('data-expanded', 'false');
               }
               setTimeout(addNumberLabels, 500);

// Handle window resize for responsive design
            function handleResize() {
               const container = document.getElementById('user-aid-voice-navigation');
               if (container) {
                  if (window.innerWidth <= 768) {
                     container.style.width = '95%';
                     container.style.maxWidth = 'none';
                     container.style.bottom = '10px';
                  } else {
                     container.style.width = '90%';
                     container.style.maxWidth = '600px';
                     container.style.bottom = '20px';
                  }
               }

// Update number labels if they're visible
               if (document.querySelectorAll('.user-aid-number-label').length > 0) {
                  addNumberLabels();
               }
            }
            break;

// voice navigtation ened here

case "Pause Animation":
            // let isPaused = document.body.dataset.animationsPaused === "true";

// if (!isPaused) {
               document.body.dataset.animationsPaused = "true";
               let pauseStyle = document.createElement("style");
               pauseStyle.id = "pauseAnimationStyle";
               pauseStyle.innerHTML = `
                        * {
                            animation-play-state: paused !important;
                            transition: none !important;
                        }
                         `;
               document.head.appendChild(pauseStyle);
            // } 
            // else {
            //       document.body.dataset.animationsPaused = "false";
            //       let existingStyle = document.getElementById("pauseAnimationStyle");
            //       if (existingStyle) {
            //           existingStyle.remove();
            //       }
            //      }
            break;

case "Hide Images":
            document.querySelectorAll("img").forEach((img) => {
               img.style.visibility = "hidden";
            });
            break;
            
        case "unselected:Hide Images":
                document.querySelectorAll("img").forEach((img) => {
                    img.style.visibility = "visible";
                });
                break;

// GLOBAL FUNCTION: Remove All Features
            function removeAllFeatures() {
               document.body.dataset.cursor = "";

// Remove Big Cursor
               document.documentElement.style.cursor = "default";
               let existingCursorStyle = document.getElementById("bigCursorStyle");
               if (existingCursorStyle) existingCursorStyle.remove();

// Remove Reading Mask
               let existingMask = document.getElementById("readingMask");
               if (existingMask) existingMask.remove();

// Remove Reading Guide
               let existingGuide = document.getElementById("readingGuide");
               if (existingGuide) existingGuide.remove();
               let existingGuideStyle = document.getElementById("readingGuideStyle");
               if (existingGuideStyle) existingGuideStyle.remove();

// Remove Reading Guide Mouse Event
               // document.removeEventListener("mousemove", moveReadingGuide);
            }

case "Big Cursor":
            const wasActive = document.body.dataset.cursor === "big";
            document.body.dataset.cursor = wasActive ? "" : "big";
            if (!wasActive) {
               // Apply cursor to main page
               const cursorStyle = document.createElement('style');
               cursorStyle.id = 'bigCursorStyle';
               cursorStyle.textContent = `
            * {
                cursor: url('https://softsuitetech.com/DEMO/widget/images/arrow_white.png'), auto !important;
            }
        `;
               document.head.appendChild(cursorStyle);

// Apply to all same-origin iframes
               document.querySelectorAll('iframe').forEach(iframe => {
                  try {
                     const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
                     const iframeStyle = iframeDoc.createElement('style');
                     iframeStyle.textContent = `
                    * {
                        cursor: url('https://softsuitetech.com/DEMO/widget/images/arrow_white.png'), auto !important;
                    }
                `;
                     iframeDoc.head.appendChild(iframeStyle);
                  } catch (e) {
                     // Cross-origin iframe - use postMessage
                     iframe.contentWindow.postMessage({
                        action: "applyBigCursor",
                        cursorUrl: 'https://softsuitetech.com/DEMO/widget/images/arrow_white.png'
                     }, "*");
                  }
               });

} else {
               // Remove from main page
               const existingStyle = document.getElementById('bigCursorStyle');
               if (existingStyle) existingStyle.remove();

// Remove from all iframes
               document.querySelectorAll('iframe').forEach(iframe => {
                  try {
                     const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
                     const styles = iframeDoc.querySelectorAll('style');
                     styles.forEach(style => {
                        if (style.textContent.includes('cursor')) style.remove();
                     });
                  } catch (e) {
                     // Cross-origin iframe
                     iframe.contentWindow.postMessage({
                        action: "removeBigCursor"
                     }, "*");
                  }
               });
            }
            break;

case "Dark Cursor":
            const wasActive1 = document.body.dataset.cursor === "big1";
            console.log("Dark Cursor12345678", wasActive1);
            document.body.dataset.cursor = wasActive1 ? "" : "big1";
            if (!wasActive1) {
               // Apply cursor to main page
               const cursorStyle = document.createElement('style');
               cursorStyle.id = 'bigDarkCursorStyle';
               cursorStyle.textContent = `
            * {
                cursor: url('https://softsuitetech.com/DEMO/widget/images/arrow_black.svg'), auto !important;
            }
        `;
               document.head.appendChild(cursorStyle);

// Apply to all same-origin iframes
               document.querySelectorAll('iframe').forEach(iframe => {
                  try {
                     const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
                     const iframeStyle = iframeDoc.createElement('style');
                     iframeStyle.textContent = `
                    * {
                        cursor: url('https://softsuitetech.com/DEMO/widget/images/arrow_black.svg'), auto !important;
                    }
                `;
                     iframeDoc.head.appendChild(iframeStyle);
                  } catch (e) {
                     // Cross-origin iframe - use postMessage
                     iframe.contentWindow.postMessage({
                        action: "applyBigDarkCursor",
                        cursorUrl: 'https://softsuitetech.com/DEMO/widget/images/arrow_black.svg'
                     }, "*");
                  }
               });

} else {
               // Remove from main page
               const existingStyle = document.getElementById('bigDarkCursorStyle');
               if (existingStyle) existingStyle.remove();

// Remove from all iframes
               document.querySelectorAll('iframe').forEach(iframe => {
                  try {
                     const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
                     const styles = iframeDoc.querySelectorAll('style');
                     styles.forEach(style => {
                        if (style.textContent.includes('cursor')) style.remove();
                     });
                  } catch (e) {
                     // Cross-origin iframe
                     iframe.contentWindow.postMessage({
                        action: "removeBigDarkCursor"
                     }, "*");
                  }
               });
            }

break;

case "unselected:Dark Cursor":
            const iframe = document.getElementById("reactWidgetIframe");
            iframe.contentWindow.postMessage({
               action: "removeBigDarkCursor"
            }, "*");
            break;

case "Reading Mask":
            removeAllFeatures();

// Get current mouse position
            let currentMousePosition = {
               x: 0,
               y: window.innerHeight - 100
            };

try {
               const mouseEvent = new MouseEvent('mousemove');
               document.dispatchEvent(mouseEvent);

if (mouseEvent.screenX) {
                  currentMousePosition.x = mouseEvent.clientX;
                  currentMousePosition.y = mouseEvent.clientY;
               }
            } catch (e) {
               console.log("Using fallback position detection");
            }

// Create the reading mask elements
            let readingMask = document.createElement("div");
            readingMask.id = "readingMask";
            readingMask.style.position = "fixed";
            readingMask.style.top = "0";
            readingMask.style.left = "0";
            readingMask.style.width = "100%";
            readingMask.style.height = "100%";
            readingMask.style.pointerEvents = "none";
            readingMask.style.zIndex = "2147483646"; // One below the window
            readingMask.style.opacity = "0"; // Start invisible until positioned

let topMask = document.createElement("div");
            topMask.style.position = "absolute";
            topMask.style.width = "100%";
            topMask.style.height = "50%"; // Initial height - will be updated
            topMask.style.top = "0";
            topMask.style.backgroundColor = "rgba(0, 0, 0, 0.75)";

let bottomMask = document.createElement("div");
            bottomMask.style.position = "absolute";
            bottomMask.style.width = "100%";
            bottomMask.style.height = "50%"; // Initial height - will be updated
            bottomMask.style.bottom = "0";
            bottomMask.style.backgroundColor = "rgba(0, 0, 0, 0.75)";

let readingWindow = document.createElement("div");
            readingWindow.id = "readingWindow";
            readingWindow.style.position = "absolute";
            readingWindow.style.left = "0";
            readingWindow.style.width = "100%";
            readingWindow.style.height = "180px";
            readingWindow.style.backgroundColor = "transparent";
            readingWindow.style.borderTop = "3px solid #0080ff";
            readingWindow.style.borderBottom = "3px solid #00ff80";
            readingWindow.style.boxShadow = "0px 0px 15px rgba(255, 255, 255, 0.3)";
            readingWindow.style.zIndex = "2147483647"; // Maximum z-index

// Assemble the mask
            readingMask.appendChild(topMask);
            readingMask.appendChild(bottomMask);
            readingMask.appendChild(readingWindow);

// Add the mask to DOM but keep invisible until positioned
            document.body.appendChild(readingMask);

// Define the function to get real mouse position
            function getRealMousePosition() {
               return new Promise((resolve) => {
                  // First try: Get position from a pointer event (most accurate)
                  function onFirstPointerMove(e) {
                     document.removeEventListener('pointermove', onFirstPointerMove);
                     resolve({
                        x: e.clientX,
                        y: e.clientY
                     });
                  }
                  document.addEventListener('pointermove', onFirstPointerMove, {
                     once: true
                  });

// Fallback: If no pointer event in 5ms, use mousemove
                  setTimeout(() => {
                     document.removeEventListener('pointermove', onFirstPointerMove);

// Final fallback: If no events at all, use current position or screen center
                     setTimeout(() => {
                        document.removeEventListener('mousemove', onFirstMouseMove);
                        resolve(currentMousePosition);
                     }, 5);
                  }, 5);
               });
            }

// Define the position update function - OUTSIDE any conditional block
            function updateReadingMaskPosition(clientY) {
               let maskHeight = readingWindow.offsetHeight / 2;
               let newY = clientY - maskHeight;

readingWindow.style.top = `${newY}px`;
               topMask.style.height = `${newY}px`;
               bottomMask.style.height = `${window.innerHeight - newY - readingWindow.offsetHeight}px`;
               bottomMask.style.top = `${newY + readingWindow.offsetHeight}px`;
            }

// Handle iframe communication
            let iframe12 = document.getElementById("reactWidgetIframe");
            if (iframe12) {
               // Tell iframe not to create its own reading mask
               iframe12.contentWindow.postMessage({
                  action: "parentReadingMaskActive",
                  message: "Use parent reading guide, don't create your own"
               }, "*");

// Enhanced message listener for iframe events
               const messageHandler = function (event) {
                  // Handle mouse movement from iframe
                  if (event.data && event.data.action === "mouseMoveInIframe" && event.data.coordinates) {
                     // Convert iframe coordinates to document coordinates
                     const iframeRect = iframe12.getBoundingClientRect();
                     const adjustedY = event.data.coordinates.y + iframeRect.top;

// Update current position
                     currentMousePosition.y = adjustedY;

// Update reading mask position based on iframe mouse position
                     requestAnimationFrame(() => updateReadingMaskPosition(adjustedY));
                  }

// Handle flyout state changes
                  if (event.data && event.data.type === "TOGGLE_FLYOUT") {
                     if (event.data.isFlyoutOpen) {
                        // When flyout opens, ensure mask stays on top
                        readingMask.style.zIndex = "2147483646";
                        readingWindow.style.zIndex = "2147483647";

// Force position update with current mouse position
                        updateReadingMaskPosition(currentMousePosition.y);
                     }
                  }
               };

// Remove any existing message handlers to avoid duplicates
               window.removeEventListener("message", messageHandler);
               window.addEventListener("message", messageHandler);
            }

// Position initialization AFTER both function definitions and iframe setup
            getRealMousePosition().then(pos => {
               updateReadingMaskPosition(pos.y);
               readingMask.style.opacity = "1"; // Make visible after positioning

// Add mouse movement tracking for the parent document
               document.addEventListener("mousemove", function (e) {
                  currentMousePosition.x = e.clientX;
                  currentMousePosition.y = e.clientY;
                  requestAnimationFrame(() => updateReadingMaskPosition(e.clientY));
               });
            });
            break;

// ✅ CASE: READING GUIDE (Fixed Alignment & Centered Cursor)
           case "Reading Guide":
             console.log("✅ Reading Guide mode activated!");
 
             // Store state in localStorage for persistence across widget reopening
             if (localStorage.getItem('readingGuideActive') === 'true') {
                console.log("Reading guide should be active based on localStorage");
             }
 
             // Check if guide exists visually
             const guideElement = document.getElementById("readingGuide");
 
             // Get current state from data attribute (but don't trust it completely)
             const dataAttribute = document.documentElement.dataset.readingGuideActive;
 
             // Determine true active state (element exists OR localStorage says it should be active)
             const isActive = guideElement !== null || localStorage.getItem('readingGuideActive') === 'true';
 
             // Toggle functionality
             if (isActive && guideElement) {
                console.log("Deactivating Reading Guide");
 
                // Remove the guide element
                // guideElement.remove();
 
                // Remove style
                // const guideStyle = document.getElementById("readingGuideStyle");
                // if (guideStyle) guideStyle.remove();
 
                // Remove event listeners
                // if (window.readingGuideMoveHandler) {
                //    document.removeEventListener("mousemove", window.readingGuideMoveHandler);
                //    delete window.readingGuideMoveHandler;
                // }
 
                // Clean up observers and intervals
                // if (window.readingGuideObserver) {
                //    window.readingGuideObserver.disconnect();
                //    delete window.readingGuideObserver;
                // }
 
                // if (window.readingGuideInterval) {
                //    clearInterval(window.readingGuideInterval);
                //    delete window.readingGuideInterval;
                // }
 
                // Always set data attribute to false when deactivating
                // document.documentElement.dataset.readingGuideActive = "false";
 
                // Clear localStorage state
                // localStorage.removeItem('readingGuideActive');
 
                break;
             }
 
             // If we get here, we're activating the guide (or re-activating it)
 
             // Set both localStorage and data attribute for persistence
             localStorage.setItem('readingGuideActive', 'true');
             document.documentElement.dataset.readingGuideActive = "true";
 
             // Create style if it doesn't exist
             if (!document.getElementById("readingGuideStyle")) {
                let guideStyle = document.createElement("style");
                guideStyle.id = "readingGuideStyle";
                guideStyle.innerHTML = `
             #readingGuide {
                 position: fixed;
                 z-index: 2147483647; /* Max z-index */
                 display: flex;
                 flex-direction: column;
                 align-items: center;
                 pointer-events: none;
                 will-change: transform; /* Performance optimization */
                 transform: translateZ(0); /* Force GPU acceleration */
             }
 
             .guide-bar {
                 width: 500px;
                 height: 8px;
                 background-color: black;
                 border-radius: 5px;
                 border: 2px solid yellow;
                 box-shadow: 0px 0px 10px rgba(255, 255, 0, 0.8);
             }
 
             .guide-arrow {
                 width: 0;
                 height: 0;
                 border-left: 14px solid transparent;
                 border-right: 14px solid transparent;
                 border-bottom: 18px solid black;
                 position: absolute;
                 top: -12px;
             }
         `;
                document.head.appendChild(guideStyle);
             }
 
             // Create guide element if it doesn't exist
             if (!document.getElementById("readingGuide")) {
                let guideBar = document.createElement("div");
                guideBar.id = "readingGuide";
                guideBar.innerHTML = `
             <div class="guide-arrow"></div>
             <div class="guide-bar"></div>
         `;
                document.body.appendChild(guideBar);
             }
 
             // Create mouse tracking function if not already defined
             if (!window.readingGuideMoveHandler) {
                window.readingGuideMoveHandler = function (event) {
                   // Always check both localStorage and data attribute for activation state
                   if (localStorage.getItem('readingGuideActive') !== 'true') {
                      // If localStorage says inactive but data attribute says active, correct it
                      if (document.documentElement.dataset.readingGuideActive === "true") {
                         document.documentElement.dataset.readingGuideActive = "false";
                      }
                      return;
                   }
 
                   // Force data attribute to match localStorage (fixes widget reopening issue)
                   if (document.documentElement.dataset.readingGuideActive !== "true") {
                      document.documentElement.dataset.readingGuideActive = "true";
                   }
 
                   const guide = document.getElementById("readingGuide");
                   if (guide) {
                      guide.style.top = `${event.clientY}px`;
                      guide.style.left = `${event.clientX - 250}px`;
                   } else if (localStorage.getItem('readingGuideActive') === 'true') {
                      // Guide should exist but doesn't - recreate it
                      let newGuide = document.createElement("div");
                      newGuide.id = "readingGuide";
                      newGuide.innerHTML = `
                     <div class="guide-arrow"></div>
                     <div class="guide-bar"></div>
                 `;
                      document.body.appendChild(newGuide);
                   }
                };
 
                // Add mouse movement listener
                document.addEventListener("mousemove", window.readingGuideMoveHandler);
             }
 
             // Create message handler for cross-frame communication
             if (!window.readingGuideMessageHandler) {
                window.readingGuideMessageHandler = function (event) {
                   // Process widget messages
                   if (event.data && event.data.type === "TOGGLE_FLYOUT") {
                      console.log("Widget toggled flyout:", event.data);
 
                      // Check true state - always trust localStorage over attribute
                      if (localStorage.getItem('readingGuideActive') === 'true') {
                         // Ensure data attribute is correct
                         document.documentElement.dataset.readingGuideActive = "true";
 
                         // Ensure guide exists
                         if (!document.getElementById("readingGuide")) {
                            let newGuide = document.createElement("div");
                            newGuide.id = "readingGuide";
                            newGuide.innerHTML = `
                             <div class="guide-arrow"></div>
                             <div class="guide-bar"></div>
                         `;
                            document.body.appendChild(newGuide);
                         }
 
                         // Re-append to ensure it's on top of any new elements
                         const guide = document.getElementById("readingGuide");
                         if (guide) {
                            document.body.appendChild(guide);
                         }
                      }
                   }
 
                   // Handle iframe mouse movement data
                   if (event.data && event.data.action === "mouseMoveInIframe" && event.data.coordinates) {
                      // Only process if reading guide is active
                      if (localStorage.getItem('readingGuideActive') !== 'true') return;
 
                      const guide = document.getElementById("readingGuide");
                      if (!guide) return;
 
                      // Find source iframe
                      let sourceIframe = null;
 
                      try {
                         // Try window reference method
                         document.querySelectorAll('iframe').forEach(iframe => {
                            if (iframe.contentWindow === event.source) {
                               sourceIframe = iframe;
                            }
                         });
                      } catch (e) {
                         // Fall back to known widget iframe
                         sourceIframe = document.getElementById("reactWidgetIframe") ||
                            document.querySelector('iframe[title*="accessibility"]');
                      }
 
                      if (sourceIframe) {
                         const iframeRect = sourceIframe.getBoundingClientRect();
                         const absoluteX = event.data.coordinates.x + iframeRect.left;
                         const absoluteY = event.data.coordinates.y + iframeRect.top;
 
                         guide.style.top = `${absoluteY}px`;
                         guide.style.left = `${absoluteX - 250}px`;
                      }
                   }
                };
 
                // Add message listener
                window.addEventListener("message", window.readingGuideMessageHandler);
             }
 
             // Create mutation observer if not already defined
             if (!window.readingGuideObserver) {
                window.readingGuideObserver = new MutationObserver(mutations => {
                   // Only process if reading guide should be active
                   if (localStorage.getItem('readingGuideActive') !== 'true') return;
 
                   // Always ensure data attribute matches localStorage
                   if (document.documentElement.dataset.readingGuideActive !== "true") {
                      document.documentElement.dataset.readingGuideActive = "true";
                   }
 
                   // Check for guide element
                   const guide = document.getElementById("readingGuide");
                   if (!guide) {
                      // Guide is missing but should be active - recreate it
                      let newGuide = document.createElement("div");
                      newGuide.id = "readingGuide";
                      newGuide.innerHTML = `
                     <div class="guide-arrow"></div>
                     <div class="guide-bar"></div>
                 `;
                      document.body.appendChild(newGuide);
                      return;
                   }
 
                   // Keep guide on top
                   guide.style.zIndex = "2147483647";
 
                   // Special handling for potential widget changes
                   mutations.forEach(mutation => {
                      if (mutation.attributeName === "data-reading-guide-active") {
                         const attrValue = document.documentElement.dataset.readingGuideActive;
 
                         // If data attribute was changed to false but localStorage says true,
                         // this is likely the widget reopening issue - correct it immediately
                         if (attrValue === "false" && localStorage.getItem('readingGuideActive') === 'true') {
                            document.documentElement.dataset.readingGuideActive = "true";
                         }
                      }
 
                      // Check for added accessibility widget elements
                      if (mutation.addedNodes.length > 0) {
                         mutation.addedNodes.forEach(node => {
                            if (node.nodeType === 1) { // Element node
                               if (
                                  node.id?.includes('accessibility') ||
                                  (typeof node.className === 'string' && node.className?.includes('accessibility'))
                               ) {
                                  // Widget element detected - reattach guide to stay on top
                                  if (guide) {
                                     document.body.appendChild(guide);
                                  }
                               }
                            }
                         });
                      }
                   });
                });
 
                // Start observing both body for content changes and html for attribute changes
                window.readingGuideObserver.observe(document.body, {
                   childList: true,
                   subtree: true
                });
 
                window.readingGuideObserver.observe(document.documentElement, {
                   attributes: true,
                   attributeFilter: ['data-reading-guide-active']
                });
             }
 
             // Create interval for periodic checks
             if (!window.readingGuideInterval) {
                window.readingGuideInterval = setInterval(() => {
                   // Check localStorage state
                   if (localStorage.getItem('readingGuideActive') !== 'true') {
                      // If not active, clean up
                      clearInterval(window.readingGuideInterval);
                      delete window.readingGuideInterval;
                      return;
                   }
 
                   // Always ensure data attribute matches localStorage
                   if (document.documentElement.dataset.readingGuideActive !== "true") {
                      document.documentElement.dataset.readingGuideActive = "true";
                   }
 
                   // Verify guide existence
                   const guide = document.getElementById("readingGuide");
                   if (!guide) {
                      // Guide is missing but should be active - recreate it
                      let newGuide = document.createElement("div");
                      newGuide.id = "readingGuide";
                      newGuide.innerHTML = `
                     <div class="guide-arrow"></div>
                     <div class="guide-bar"></div>
                 `;
                      document.body.appendChild(newGuide);
                   }
 
                   // Notify iframes about reading guide
                   document.querySelectorAll('iframe').forEach(iframe => {
                      try {
                         iframe.contentWindow.postMessage({
                            action: "parentReadingGuideActive",
                            message: "Use parent reading guide, don't create your own"
                         }, "*");
                      } catch (e) {
                         // Cross-origin iframe
                      }
                   });
                }, 1000);
             }
 
             console.log("Reading Guide activated with attribute persistence");
             break;

// ✅ REMOVE EVERYTHING WHEN "unselected:Bigger Cursor" IS RECEIVED
         case "unselected:Big Cursor":
            const iframeBigCursor = document.getElementById("reactWidgetIframe");
            iframeBigCursor.contentWindow.postMessage({
               action: "removeBigCursor"
            }, "*");

case "unselected:Reading Mask":
            // Call the cleanup function if it exists
            if (typeof window.cleanupReadingMask === 'function') {
               window.cleanupReadingMask();
               // After cleanup, delete the reference
               delete window.cleanupReadingMask;
            } else {
               // Fallback cleanup if the function doesn't exist
               const readingMask = document.getElementById("readingMask") ||
                  document.querySelector("[id^='readingMask_']");
               if (readingMask && readingMask.parentNode) {
                  readingMask.parentNode.removeChild(readingMask);
               }
            }

// Notify all iframes about the deactivation
            const allIframes = document.querySelectorAll('iframe');
            allIframes.forEach(iframe => {
               try {
                  iframe.contentWindow.postMessage({
                     action: "readingMaskDeactivated",
                     message: "Reading mask has been turned off"
                  }, "*");
               } catch (error) {
                  // Handle cross-origin errors silently
                  console.debug("Could not send deactivation message to iframe, possible cross-origin restriction");
               }
            });

// For backward compatibility with your existing code
            const iframeWidgetReading = document.getElementById("reactWidgetIframe");
            if (iframeWidgetReading) {
               try {
                  iframeWidgetReading.contentWindow.postMessage({
                     action: "unSelectedAppCursors"
                  }, "*");
               } catch (error) {
                  console.debug("Could not send unSelectedAppCursors message to iframe");
               }
            }

// Remove any event listeners that might have been added
            const removeGlobalListeners = () => {
               // Remove known event listeners from the document
               document.removeEventListener("mousemove", window.throttledUpdatePosition);
               window.removeEventListener("message", window.readingMaskMessageHandler);

// Clean up stored references to event handlers
               delete window.throttledUpdatePosition;
               delete window.readingMaskMessageHandler;
            };

removeGlobalListeners();

// Call removeAllFeatures last to ensure any other features are also cleaned up
            removeAllFeatures();
            break;

case "Legible Fonts":
            // Load Google Font (Roboto) if not already loaded
            if (!document.getElementById("legibleFontLink")) {
               const link = document.createElement("link");
               link.id = "legibleFontLink";
               link.rel = "stylesheet";
               link.href = "https://fonts.googleapis.com/css2?family=Roboto&display=swap";
               document.head.appendChild(link);
            }

// Apply Roboto font to all elements
            document.querySelectorAll("*").forEach((element) => {
               element.style.setProperty("font-family", "'Roboto', sans-serif", "important");
            });
            break;

case "Dyslexic Friendly":
            // Load OpenDyslexic font if not already loaded
            if (!document.getElementById("dyslexicFontStyle")) {
               const style = document.createElement("style");
               style.id = "dyslexicFontStyle";
               style.innerHTML = `
            @import url('https://fonts.cdnfonts.com/css/open-dyslexic');
        `;
               document.head.appendChild(style);

// Add a small delay to ensure the font is loaded before applying
               setTimeout(() => {
                  // Apply font to body first
                  document.body.style.setProperty("font-family", "'OpenDyslexic', sans-serif", "important");
                  // document.body.style.setProperty("letter-spacing", "0.05rem", "important");
                  document.body.style.setProperty("font-weight", "400", "important");

// Then apply to all other elements
                  applyStylesToDocumentExceptWidget((element) => {
                     element.style.setProperty("font-family", "'OpenDyslexic', sans-serif", "important");
                     // element.style.setProperty("letter-spacing", "0.05rem", "important");
                  });
               }, 300);
            } else {
               // Font already loaded, apply immediately
               // Apply to body first
               document.body.style.setProperty("font-family", "'OpenDyslexic', sans-serif", "important");
               // document.body.style.setProperty("letter-spacing", "0.05rem", "important");
               document.body.style.setProperty("font-weight", "400", "important");

// Dictionary start from here

case "Dictionary":
                if (document.body.dataset.dictionary === "on") {
                    document.body.dataset.dictionary = "off";
                    document.removeEventListener("mouseup", handleTextSelection);
                    console.log("Dictionary mode OFF");
                } else {
                    document.body.dataset.dictionary = "on";

// Add styles for modern UI
                    function addDictionaryStyles() {
                        const styleId = 'dictionaryStyles';
                        if (document.getElementById(styleId)) return;

// Azure Translator configuration
                    const translatorConfig = {
                        key: "6mEKfTLv7H7SP6h9uKVhPl5cwJ8gPJG3qKs0VIouEaCn3ntwme37JQQJ99BDAC1i4TkXJ3w3AAAbACOGK8hE",
                        region: "centralus",
                        endpoint: "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0"
                    };

// Dictionary API configuration
                    const DICTIONARY_APIS = {
                        // Free dictionary API
                        freeDict: {
                            name: "Free Dictionary API",
                            endpoint: "https://api.dictionaryapi.dev/api/v2/entries/{lang}/{word}",
                            languages: ["en", "fr", "es", "de", "it", "ru", "ja"],
                            transformResponse: (data) => {
                                if (!Array.isArray(data) || data.length === 0) return null;

// Get synonyms if available
                                const synonyms = [];
                                data[0].meanings?.forEach(meaning => {
                                    if (meaning.synonyms && meaning.synonyms.length > 0) {
                                        meaning.synonyms.slice(0, 5).forEach(syn => {
                                            if (!synonyms.includes(syn)) {
                                                synonyms.push(syn);
                                            }
                                        });
                                    }
                                });

return {
                                    word: data[0].word,
                                    phonetic: data[0].phonetic || data[0].phonetics?.find(p => p.text)?.text || "",
                                    meanings: data[0].meanings?.map(m => ({
                                        partOfSpeech: m.partOfSpeech,
                                        definitions: m.definitions.map(d => ({
                                            definition: d.definition,
                                            example: d.example || null
                                        }))
                                    })) || [],
                                    synonyms: synonyms.length > 0 ? synonyms : null
                                };
                            }
                        },
                        // Wiktionary API (through Wikimedia API)
                        wiktionary: {
                            name: "Wiktionary",
                            endpoint: "https://en.wiktionary.org/api/rest_v1/page/definition/{word}",
                            languages: ["en", "fr", "es", "de", "it", "pt", "ru", "ja", "zh", "ko", "ar"],
                            transformResponse: (data) => {
                                if (!data || !data[Object.keys(data)[0]]) return null;

const entries = data[Object.keys(data)[0]];
                                if (!entries || !Array.isArray(entries)) return null;

return {
                                    word: Object.keys(data)[0],
                                    phonetic: "",
                                    meanings: meanings,
                                    synonyms: null
                                };
                            }
                        }
                    };

// Common language codes - updated to match provided table
                    const LANGUAGES = {
                        en: {
                            name: "English",
                            dictApiCode: "en"
                        },
                        fr: {
                            name: "French",
                            dictApiCode: "fr"
                        },
                        es: {
                            name: "Spanish",
                            dictApiCode: "es"
                        },
                        it: {
                            name: "Italian",
                            dictApiCode: "it"
                        },
                        ru: {
                            name: "Russian",
                            dictApiCode: "ru"
                        },
                        nl: {
                            name: "Dutch",
                            dictApiCode: "nl"
                        },
                        tr: {
                            name: "Turkish",
                            dictApiCode: "tr"
                        },
                        pl: {
                            name: "Polish",
                            dictApiCode: "pl"
                        },
                        gr: {
                            name: "German",
                            dictApiCode: "de"
                        }, // Using 'de' for dictionary API
                        ar: {
                            name: "Arabic",
                            dictApiCode: "ar"
                        },
                        "zh-Hans": {
                            name: "Chinese (Simplified)",
                            dictApiCode: "zh"
                        }
                    };

// Get user's preferred language for translations
                    function getUserPreferredLanguage() {
                        // Default to browser language or English if not found
                        const browserLang = navigator.language.split('-')[0];
                        return browserLang in LANGUAGES ? browserLang : 'en';
                    }

// Gets both dictionary definition, English definition and translations
                    async function getLanguageData(word) {
                        try {
                            // First detect the language
                            const detectedLang = await detectLanguageAPI(word);
                            const userLang = getUserPreferredLanguage();

// Always get translation to English for all non-English words
                            const needsEnglishTranslation = detectedLang !== 'en';

// Get translation to user's language if different from detected and English
                            const needsUserTranslation = detectedLang !== userLang && userLang !== 'en';

// Parallel API calls to improve speed
                            const results = await Promise.allSettled([
                                // 1. Try to get definition in original language
                                getDefinition(word, detectedLang),

// 2. Get English translation if needed (for better dictionary lookup)
                                needsEnglishTranslation ?
                                    translateText(word, detectedLang, 'en') :
                                    Promise.resolve(null),

// 3. Get user language translation if needed
                                needsUserTranslation ?
                                    translateText(word, detectedLang, userLang) :
                                    Promise.resolve(null)
                            ]);

// Extract results
                            const originalDefinition = results[0].status === 'fulfilled' ? results[0].value : null;
                            const englishTranslation = results[1].status === 'fulfilled' ? results[1].value : null;
                            const userTranslation = results[2].status === 'fulfilled' ? results[2].value : null;

// If we have an English translation and no original definition, try to get English definition
                            let englishDefinition = null;
                            if (englishTranslation && (!originalDefinition || originalDefinition.meanings?.length === 0)) {
                                englishDefinition = await getDefinition(englishTranslation, 'en');
                            }

// Combine all data
                            return {
                                word,
                                originalWord: word,
                                definition: originalDefinition,
                                englishTranslation,
                                englishDefinition,
                                userTranslation,
                                sourceLang: detectedLang,
                                targetLang: userLang
                            };
                        } catch (error) {
                            console.error("Error in getLanguageData:", error);
                            return {
                                word,
                                originalWord: word,
                                definition: null,
                                englishTranslation: null,
                                englishDefinition: null,
                                userTranslation: null,
                                sourceLang: "unknown",
                                targetLang: getUserPreferredLanguage(),
                                error: "Error processing request"
                            };
                        }
                    }

// Get definition from dictionary API
                    async function getDefinition(word, lang) {
                        if (!word) return null;

// Map language code to dictionary API format if needed
                        // Handle special case for German (gr in table, but de for API)
                        const apiLang = lang === 'gr' ? 'de' : lang;

// Try the free dictionary API first
                        try {
                            // Map language code to dictionary API format if needed
                            const dictLang = LANGUAGES[apiLang]?.dictApiCode || apiLang;

// Check if the API supports this language
                            if (!DICTIONARY_APIS.freeDict.languages.includes(apiLang)) {
                                // Try alternate APIs or fallback to translation
                                return null;
                            }

const url = DICTIONARY_APIS.freeDict.endpoint
                                .replace('{lang}', dictLang)
                                .replace('{word}', encodeURIComponent(word));

const response = await fetch(url);

if (!response.ok) {
                                throw new Error(`Dictionary API returned ${response.status}`);
                            }

const data = await response.json();
                            return DICTIONARY_APIS.freeDict.transformResponse(data);
                        } catch (error) {
                            console.error("Definition error:", error);

// Try Wiktionary as fallback for certain languages
                            try {
                                if (apiLang === 'en') {
                                    const wiktUrl = DICTIONARY_APIS.wiktionary.endpoint
                                        .replace('{word}', encodeURIComponent(word));

const wiktResponse = await fetch(wiktUrl);

if (!wiktResponse.ok) {
                                        return null;
                                    }

const wiktData = await wiktResponse.json();
                                    return DICTIONARY_APIS.wiktionary.transformResponse(wiktData);
                                }
                            } catch (wiktError) {
                                console.error("Wiktionary fallback error:", wiktError);
                            }

return null;
                        }
                    }

// Use Azure Translator to translate text
                    async function translateText(text, sourceLang, targetLang) {
                        if (!text || sourceLang === targetLang) return null;

// Handle special case for German (gr in table, but de for API)
                        const apiSourceLang = sourceLang === 'gr' ? 'de' : sourceLang;
                        const apiTargetLang = targetLang === 'gr' ? 'de' : targetLang;

// Handle special case for Chinese
                        const sourceParam = apiSourceLang === 'zh-Hans' ? 'zh-Hans' : apiSourceLang;
                        const targetParam = apiTargetLang === 'zh-Hans' ? 'zh-Hans' : apiTargetLang;

const url = `${translatorConfig.endpoint}&from=${sourceParam}&to=${targetParam}`;

try {
                            const response = await fetch(url, {
                                method: 'POST',
                                headers: {
                                    'Ocp-Apim-Subscription-Key': translatorConfig.key,
                                    'Ocp-Apim-Subscription-Region': translatorConfig.region,
                                    'Content-Type': 'application/json'
                                },
                                body: JSON.stringify([{
                                    Text: text
                                }])
                            });

if (!response.ok) {
                                throw new Error(`Azure error: ${response.status}`);
                            }

const data = await response.json();
                            return data[0]?.translations?.[0]?.text || null;
                        } catch (error) {
                            console.error("Translation error:", error);
                            return null;
                        }
                    }

// Use Azure's language detection API instead of simple heuristics
                    async function detectLanguageAPI(text) {
                        if (!text) return getUserPreferredLanguage();

// For very short texts, use simpler detection
                        if (text.length < 4) {
                            return simpleLanguageDetection(text);
                        }

const url = "https://api.cognitive.microsofttranslator.com/detect?api-version=3.0";

if (!response.ok) {
                                throw new Error(`Azure language detection error: ${response.status}`);
                            }

const data = await response.json();
                            let detectedLang = data[0]?.language || getUserPreferredLanguage();

// Map detected language to our language list if needed
                            // Special case for German - API returns 'de' but our table uses 'gr'
                            if (detectedLang === 'de') detectedLang = 'gr';

// Special case for zh-Hans/zh
                            if (detectedLang === 'zh') detectedLang = 'zh-Hans';

// Ensure we have support for this language
                            return detectedLang in LANGUAGES ? detectedLang : getUserPreferredLanguage();
                        } catch (error) {
                            console.error("Language detection error:", error);
                            return simpleLanguageDetection(text);
                        }
                    }

// Fallback language detection when API fails or for very short texts
                    function simpleLanguageDetection(text) {
                        // Common language patterns
                        const patterns = {
                            gr: /[äöüßÄÖÜ]/, // German
                            fr: /[éèêëàâçîïôûùüÿÉÈÊËÀÂÇÎÏÔÛÙÜŸ]/,
                            es: /[áéíóúüñÁÉÍÓÚÜÑ]/,
                            ru: /[а-яА-ЯёЁ]/,
                            it: /[àèéìíîòóùúÀÈÉÌÍÎÒÓÙÚ]/,
                            nl: /[ijàéèêëïçÇËÏÉÈÊÄÖÜ]/,
                            pl: /[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]/,
                            tr: /[çğıöşüÇĞİÖŞÜ]/,
                            ar: /[\u0600-\u06FF]/,
                            "zh-Hans": /[\u3400-\u9FFF]/
                        };

// Check for specific character patterns
                        for (const [lang, pattern] of Object.entries(patterns)) {
                            if (pattern.test(text)) {
                                return lang;
                            }
                        }

// Default to English for Latin alphabet if no specific pattern is found
                        return 'en';
                    }

// Handle text selection
                    function handleTextSelection(event) {
                        // Don't process if clicking inside the popup
                        if (event.target.closest('#dictionaryPopup')) return;

const selection = window.getSelection();
                        if (!selection.toString().trim()) return;

const selectedText = selection.toString().trim();
                        if (selectedText.length > 100) return; // Limit length to avoid processing huge selections

// Get selection coordinates for popup positioning
                        const range = selection.getRangeAt(0);
                        const rect = range.getBoundingClientRect();

// Show loading popup first
                        showLanguagePopup(selectedText, null, rect);

// Then get data and update popup
                        getLanguageData(selectedText).then(data => {
                            // Update popup with the information
                            updatePopupWithData(data);
                        });
                    }

// Create and show popup
                    function showLanguagePopup(word, data, rect) {
                        // Add styles first
                        addDictionaryStyles();

// Remove any existing popup
                        const existingPopup = document.getElementById('dictionaryPopup');
                        if (existingPopup) {
                            existingPopup.remove();
                            document.removeEventListener('mousedown', closePopupOnClickOutside);
                        }

// Create popup element
                        const popup = document.createElement('div');
                        popup.id = 'dictionaryPopup';

// Set position
                        const scrollX = window.scrollX || window.pageXOffset;
                        const scrollY = window.scrollY || window.pageYOffset;
                        popup.style.left = `${scrollX + rect.left}px`;
                        popup.style.top = `${scrollY + rect.bottom + 10}px`;

// If no data yet, show loading spinner
                        if (!data) {
                            popup.classList.add('loading');
                            const spinner = document.createElement('div');
                            spinner.className = 'spinner';
                            popup.appendChild(spinner);
                        } else {
                            // Fill with content if data is available
                            updatePopupWithData(data, popup);
                        }

// Add to document
                        document.body.appendChild(popup);

// Add event listener to close popup when clicking outside
                        setTimeout(() => {
                            document.addEventListener('mousedown', closePopupOnClickOutside);
                        }, 100);

function closePopupOnClickOutside(e) {
                            if (popup && !popup.contains(e.target)) {
                                popup.remove();
                                document.removeEventListener('mousedown', closePopupOnClickOutside);
                            }
                        }

return popup;
                    }

// Update existing popup with data
                    function updatePopupWithData(data, popup = null) {
                        // Get popup if not provided
                        if (!popup) {
                            popup = document.getElementById('dictionaryPopup');
                            if (!popup) return;
                        }

// Remove loading class and clear content
                        popup.classList.remove('loading');
                        popup.innerHTML = '';

// Create header with word and buttons
                        const header = document.createElement('div');
                        header.className = 'header';

// Word and phonetic section
                        const wordContainer = document.createElement('div');
                        const wordEl = document.createElement('span');
                        wordEl.className = 'word';
                        wordEl.textContent = data.word;
                        wordContainer.appendChild(wordEl);

// Add language label
                        const langLabel = document.createElement('span');
                        langLabel.className = 'language-label';
                        langLabel.textContent = LANGUAGES[data.sourceLang]?.name || data.sourceLang;
                        wordContainer.appendChild(langLabel);

// Add phonetic if available
                        if (data.definition?.phonetic) {
                            const phoneticEl = document.createElement('span');
                            phoneticEl.className = 'phonetic';
                            phoneticEl.textContent = data.definition.phonetic;
                            wordContainer.appendChild(phoneticEl);
                        }

header.appendChild(wordContainer);

// Buttons container
                        const buttons = document.createElement('div');
                        buttons.className = 'buttons';

// Listen button (speech synthesis)
                        if ('speechSynthesis' in window) {
                            const listenBtn = document.createElement('button');
                            listenBtn.className = 'button listen';
                            listenBtn.innerHTML = '🔊';
                            listenBtn.title = 'Listen';
                            listenBtn.onclick = (e) => {
                                e.preventDefault();
                                e.stopPropagation();
                                speakText(data.word, data.sourceLang);
                            };
                            buttons.appendChild(listenBtn);
                        }

// Close button
                        const closeBtn = document.createElement('button');
                        closeBtn.className = 'button close';
                        closeBtn.innerHTML = '✕';
                        closeBtn.title = 'Close';
                        closeBtn.onclick = (e) => {
                            e.preventDefault();
                            e.stopPropagation();
                            e.stopImmediatePropagation();
                            popup.remove();
                            document.removeEventListener('mousedown', closePopupOnClickOutside);
                        };
                        buttons.appendChild(closeBtn);

header.appendChild(buttons);
                        popup.appendChild(header);

// Create tabs for multiple views if we have different data types
                        const hasOriginal = data.definition && data.definition.meanings && data.definition.meanings.length > 0;
                        const hasEnglish = data.englishDefinition && data.englishDefinition.meanings && data.englishDefinition.meanings.length > 0;
                        const hasTranslation = data.englishTranslation || data.userTranslation;

// If we have multiple content types, create tabs
                        if ((hasOriginal && hasEnglish) || (hasOriginal && hasTranslation) || (hasEnglish && hasTranslation)) {
                            const tabs = document.createElement('div');
                            tabs.className = 'tabs';

// Define tabs based on available data
                            const tabsConfig = [];

if (hasOriginal) {
                                tabsConfig.push({
                                    id: 'original',
                                    label: LANGUAGES[data.sourceLang]?.name || 'Original',
                                    active: true
                                });
                            }

if (hasEnglish && data.sourceLang !== 'en') {
                                tabsConfig.push({
                                    id: 'english',
                                    label: 'English',
                                    active: !hasOriginal
                                });
                            }

if (hasTranslation) {
                                tabsConfig.push({
                                    id: 'translation',
                                    label: 'Translation',
                                    active: !hasOriginal && !hasEnglish
                                });
                            }

// Create tab elements
                            tabsConfig.forEach(tabConfig => {
                                const tab = document.createElement('div');
                                tab.className = `tab ${tabConfig.active ? 'active' : ''}`;
                                tab.dataset.tab = tabConfig.id;
                                tab.textContent = tabConfig.label;
                                tab.onclick = (e) => {
                                    // Update active tab
                                    document.querySelectorAll('#dictionaryPopup .tab').forEach(t => t.classList.remove('active'));
                                    tab.classList.add('active');

// Show active content
                                    document.querySelectorAll('#dictionaryPopup .tab-content').forEach(c => c.classList.remove('active'));
                                    document.querySelector(`#dictionaryPopup .tab-content[data-tab="${tabConfig.id}"]`).classList.add('active');
                                };
                                tabs.appendChild(tab);
                            });

popup.appendChild(tabs);

// Create content for each tab
                            tabsConfig.forEach(tabConfig => {
                                const tabContent = document.createElement('div');
                                tabContent.className = `tab-content ${tabConfig.active ? 'active' : ''}`;
                                tabContent.dataset.tab = tabConfig.id;

if (tabConfig.id === 'original' && hasOriginal) {
                                    renderDefinition(tabContent, data.definition);
                                } else if (tabConfig.id === 'english' && hasEnglish) {
                                    renderDefinition(tabContent, data.englishDefinition);
                                } else if (tabConfig.id === 'translation' && hasTranslation) {
                                    renderTranslations(tabContent, data);
                                }

popup.appendChild(tabContent);
                            });
                        } else {
                            // No tabs needed, just show what we have
                            const content = document.createElement('div');
                            content.className = 'content';

if (hasOriginal) {
                                renderDefinition(content, data.definition);
                            } else if (hasEnglish) {
                                renderDefinition(content, data.englishDefinition);
                            } else if (hasTranslation) {
                                renderTranslations(content, data);
                            } else {
                                // No content available
                                const noDataEl = document.createElement('div');
                                noDataEl.className = 'no-results';
                                noDataEl.textContent = "No definition or translation available.";
                                content.appendChild(noDataEl);
                            }

popup.appendChild(content);
                        }
                    }

// Render dictionary definition
                    function renderDefinition(container, definition) {
                        if (!definition || !definition.meanings || definition.meanings.length === 0) {
                            const noDefEl = document.createElement('div');
                            noDefEl.className = 'no-results';
                            noDefEl.textContent = "No definition found.";
                            container.appendChild(noDefEl);
                            return;
                        }

// Process each meaning (part of speech)
                        definition.meanings.forEach(meaning => {
                            // Part of speech header
                            const posEl = document.createElement('div');
                            posEl.className = 'part-of-speech';
                            posEl.textContent = meaning.partOfSpeech;
                            container.appendChild(posEl);

// Show definitions (limited to 3)
                            const definitions = meaning.definitions.slice(0, 3);
                            definitions.forEach((def, index) => {
                                const defContainer = document.createElement('div');
                                defContainer.className = 'definition';

const defText = document.createElement('div');
                                const defNum = document.createElement('span');
                                defNum.className = 'definition-number';
                                defNum.textContent = `${index + 1}.`;
                                defText.appendChild(defNum);
                                defText.appendChild(document.createTextNode(' ' + def.definition));
                                defContainer.appendChild(defText);

// Add example if available
                                if (def.example) {
                                    const exampleEl = document.createElement('div');
                                    exampleEl.className = 'example';
                                    exampleEl.textContent = `"${def.example}"`;
                                    defContainer.appendChild(exampleEl);
                                }

container.appendChild(defContainer);
                            });
                        });

// Add synonyms if available
                        if (definition.synonyms && definition.synonyms.length > 0) {
                            const synonymsContainer = document.createElement('div');
                            synonymsContainer.className = 'synonyms';

const synonymsTitle = document.createElement('div');
                            synonymsTitle.className = 'synonyms-title';
                            synonymsTitle.textContent = 'Synonyms:';
                            synonymsContainer.appendChild(synonymsTitle);

definition.synonyms.forEach(synonym => {
                                const synWord = document.createElement('span');
                                synWord.className = 'synonym-word';
                                synWord.textContent = synonym;
                                synWord.onclick = () => {
                                    // Look up this synonym when clicked
                                    const selection = window.getSelection();
                                    const range = selection.getRangeAt(0);
                                    const rect = range.getBoundingClientRect();

// Show loading popup
                                    showLanguagePopup(synonym, null, rect);

// Get data for the synonym
                                    getLanguageData(synonym).then(data => {
                                        updatePopupWithData(data);
                                    });
                                };
                                synonymsContainer.appendChild(synWord);
                            });

container.appendChild(synonymsContainer);
                        }
                    }

// Render translations
                    function renderTranslations(container, data) {
                        // English translation if available
                        if (data.englishTranslation && data.sourceLang !== 'en') {
                            const engTransContainer = document.createElement('div');
                            engTransContainer.className = 'translation';

const engTransTitle = document.createElement('div');
                            engTransTitle.className = 'translation-title';
                            engTransTitle.textContent = `${LANGUAGES[data.sourceLang]?.name || data.sourceLang} → English`;
                            engTransContainer.appendChild(engTransTitle);

const engTransText = document.createElement('div');
                            engTransText.textContent = data.englishTranslation;
                            engTransContainer.appendChild(engTransText);

container.appendChild(engTransContainer);
                        }

// User language translation if available and different from English
                        if (data.userTranslation && data.targetLang !== 'en') {
                            const userTransContainer = document.createElement('div');
                            userTransContainer.className = 'translation';

const userTransTitle = document.createElement('div');
                            userTransTitle.className = 'translation-title';
                            userTransTitle.textContent = `${LANGUAGES[data.sourceLang]?.name || data.sourceLang} → ${LANGUAGES[data.targetLang]?.name || data.targetLang}`;
                            userTransContainer.appendChild(userTransTitle);

const userTransText = document.createElement('div');
                            userTransText.textContent = data.userTranslation;
                            userTransContainer.appendChild(userTransText);

container.appendChild(userTransContainer);
                        }

// If no translations available
                        if (!data.englishTranslation && !data.userTranslation) {
                            const noTransEl = document.createElement('div');
                            noTransEl.className = 'no-results';
                            noTransEl.textContent = "No translations available.";
                            container.appendChild(noTransEl);
                        }
                    }

// Text-to-speech functionality
                    function speakText(text, languageCode) {
                        if (!('speechSynthesis' in window)) return;

// Cancel any ongoing speech
                        window.speechSynthesis.cancel();

const utterance = new SpeechSynthesisUtterance(text);

// Map language code for speech API if needed
                        // Special case for German (gr in our table, but de for speech)
                        let speechLang = languageCode;
                        if (languageCode === 'gr') speechLang = 'de';
                        if (languageCode === 'zh-Hans') speechLang = 'zh';

// Get appropriate voice for language
                        const voices = window.speechSynthesis.getVoices();
                        let voice = null;

// First try to find voice that matches exactly the language code
                        voice = voices.find(v => v.lang.startsWith(speechLang));

// If no exact match, try to find voice that matches the language family
                        if (!voice) {
                            // Get first two characters of language code (e.g., "en" from "en-US")
                            const langFamily = speechLang.split('-')[0];
                            voice = voices.find(v => v.lang.startsWith(langFamily));
                        }

// If still no match, use default voice
                        if (!voice) {
                            voice = voices.find(v => v.default) || voices[0];
                        }

// Set voice if found
                        if (voice) {
                            utterance.voice = voice;
                            utterance.lang = voice.lang;
                        }

window.speechSynthesis.speak(utterance);
                    }

// Initialize by adding event listener for text selection
                    document.addEventListener("mouseup", handleTextSelection);
                    console.log("Dictionary mode ON");
                }
                break;
            // Dictionary end from here

case "HIDE_INTERFACE":
            // Create and show a confirmation modal before hiding
            const confirmModal = document.createElement("div");
            confirmModal.id = "widget-hide-confirm-modal";
            confirmModal.style.position = "fixed";
            confirmModal.style.top = "50%";
            confirmModal.style.left = "50%";
            confirmModal.style.transform = "translate(-50%, -50%)";
            confirmModal.style.backgroundColor = "#fff";
            confirmModal.style.padding = "20px";
            confirmModal.style.borderRadius = "15px"; // Increased for smoother corners like the image
            confirmModal.style.boxShadow = "0 4px 20px rgba(0,0,0,0.2)"; // Softer shadow to match the image
            confirmModal.style.zIndex = "10000";
            confirmModal.style.maxWidth = "450px";
            confirmModal.style.textAlign = "center";
            confirmModal.style.fontFamily = "Arial, sans-serif"; // Added for consistency with the image font

confirmModal.innerHTML = `
        <h3 style="font-size: 18px; font-weight: bold; color: #333; margin-bottom: 15px;">HIDE ACCESSIBILITY INTERFACE?</h3>
        <p style="margin-bottom: 25px; font-size: 14px; line-height: 1.5; color: #333;">The widget will be hidden until you clear your browser data. Do you want to proceed?</p>
        <div style="display: flex; justify-content: center; gap: 15px;">
            <button id="widget-hide-confirm-ok" style="background-color: #0066cc; color: white; border: none; padding: 10px 30px; border-radius: 25px; cursor: pointer; font-size: 14px; font-weight: 500;">OK</button>
            <button id="widget-hide-confirm-cancel" style="background-color: white; color: #0066cc; border: 2px solid #0066cc; padding: 10px 30px; border-radius: 25px; cursor: pointer; font-size: 14px; font-weight: 500;">Cancel</button>
        </div>
    `;

document.body.appendChild(confirmModal);

// Handle OK button click
            document.getElementById("widget-hide-confirm-ok").addEventListener("click", function () {
               // Hide the interface by removing the widget iframe
               const widgetIframe1 = document.getElementById("reactWidgetIframe");
               if (widgetIframe1) {
                  // Hide instead of remove
                  widgetIframe1.style.display = "none";
                  console.log("Widget iframe hidden");

// Store hidden state in localStorage
                  localStorage.setItem('widgetHidden', 'true');
               }

// Remove the confirmation modal
               document.body.removeChild(confirmModal);
            });

// Handle Cancel button click
            document.getElementById("widget-hide-confirm-cancel").addEventListener("click", function () {
               // Just remove the confirmation modal
               document.body.removeChild(confirmModal);
            });

break;

case "Page Structure":
            console.log("✅ Page Structure mode activated!");

// Define the functions at the case level (outside any conditional blocks)
            const populateHeadings = function () {
               console.log("Populating headings...");
               const headingsContent = document.getElementById('headingsContent');
               if (!headingsContent) {
                  console.error("headingsContent element not found!");
                  return;
               }

headingsContent.innerHTML = '';

// Get all heading elements
               const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');
               console.log(`Found ${headings.length} headings`);

if (headings.length === 0) {
                  headingsContent.innerHTML = '<p>No headings found on this page.</p>';
                  return;
               }

// Create a list to display headings
               const list = document.createElement('ul');
               list.className = 'structure-list';

headings.forEach(heading => {
                  const level = heading.tagName.charAt(1);
                  const item = document.createElement('li');
                  item.className = `heading-level-${level}`;

// Create a button that users can click to navigate to that heading
                  const btn = document.createElement('button');
                  btn.className = `h${level} heading-btn`;

// Show the tag and text
                  btn.innerHTML = `<span class="element-tag">&lt;h${level}&gt;</span> ${heading.textContent.trim()}`;

btn.addEventListener('click', () => {
                     heading.scrollIntoView({
                        behavior: 'smooth'
                     });
                     heading.setAttribute('tabindex', '-1');
                     heading.focus();
                     document.getElementById('pageStructureModal').classList.remove('visible');
                     document.getElementById('pageStructureModal').style.setProperty('display', 'none', 'important');
                  });

item.appendChild(btn);
                  list.appendChild(item);
               });

headingsContent.appendChild(list);
            };

const populateLandmarks = function () {
               console.log("Populating landmarks...");
               const landmarksContent = document.getElementById('landmarksContent');
               if (!landmarksContent) {
                  console.error("landmarksContent element not found!");
                  return;
               }

landmarksContent.innerHTML = '';

// Get all landmark elements (main, nav, aside, etc.)
               const landmarks = document.querySelectorAll('main, nav, aside, header, footer, section[role="region"], [role="banner"], [role="complementary"], [role="contentinfo"], [role="main"], [role="navigation"], [role="search"]');
               console.log(`Found ${landmarks.length} landmarks`);

if (landmarks.length === 0) {
                  landmarksContent.innerHTML = '<p>No landmarks found on this page.</p>';
                  return;
               }

const list = document.createElement('ul');
               list.className = 'structure-list';

landmarks.forEach(landmark => {
                  const item = document.createElement('li');

// Determine landmark type
                  let landmarkType = landmark.tagName.toLowerCase();
                  let roleAttribute = '';

if (landmark.hasAttribute('role')) {
                     roleAttribute = landmark.getAttribute('role');
                     landmarkType = roleAttribute;
                  }

const btn = document.createElement('button');
                  btn.className = 'landmark-btn';

// Try to get an accessible name
                  let name = '';
                  if (landmark.hasAttribute('aria-label')) {
                     name = landmark.getAttribute('aria-label');
                  } else if (landmark.hasAttribute('aria-labelledby')) {
                     const labelId = landmark.getAttribute('aria-labelledby');
                     const labelElement = document.getElementById(labelId);
                     if (labelElement) {
                        name = labelElement.textContent;
                     }
                  } else {
                     // Try to find a heading inside
                     const heading = landmark.querySelector('h1, h2, h3, h4, h5, h6');
                     if (heading) {
                        name = heading.textContent;
                     }
                  }

// Display tag and role (if applicable)
                  let tagDisplay = `<span class="element-tag">&lt;${landmark.tagName.toLowerCase()}`;
                  if (roleAttribute) {
                     tagDisplay += ` role="${roleAttribute}"`;
                  }
                  tagDisplay += '&gt;</span> ';

btn.innerHTML = tagDisplay + (name ? name : '(unnamed landmark)');

btn.addEventListener('click', () => {
                     landmark.scrollIntoView({
                        behavior: 'smooth'
                     });
                     landmark.setAttribute('tabindex', '-1');
                     landmark.focus();
                     document.getElementById('pageStructureModal').classList.remove('visible');
                     document.getElementById('pageStructureModal').style.setProperty('display', 'none', 'important');
                  });

item.appendChild(btn);
                  list.appendChild(item);
               });

landmarksContent.appendChild(list);
            };

const populateLinks = function () {
               console.log("Populating links...");
               const linksContent = document.getElementById('linksContent');
               if (!linksContent) {
                  console.error("linksContent element not found!");
                  return;
               }

linksContent.innerHTML = '';

// Get all links
               const links = document.querySelectorAll('a[href]');
               console.log(`Found ${links.length} links`);

if (links.length === 0) {
                  linksContent.innerHTML = '<p>No links found on this page.</p>';
                  return;
               }

const list = document.createElement('ul');
               list.className = 'structure-list';

links.forEach(link => {
                  const item = document.createElement('li');

const btn = document.createElement('button');
                  btn.className = 'link-btn';

// Show tag and text content
                  const href = link.getAttribute('href');
                  btn.innerHTML = `<span class="element-tag">&lt;a href="${href}"&gt;</span> ${link.textContent.trim() || href}`;

btn.addEventListener('click', () => {
                     link.scrollIntoView({
                        behavior: 'smooth'
                     });
                     link.focus();
                     document.getElementById('pageStructureModal').classList.remove('visible');
                     document.getElementById('pageStructureModal').style.setProperty('display', 'none', 'important');
                  });

item.appendChild(btn);
                  list.appendChild(item);
               });

linksContent.appendChild(list);
            };

// Create the modal container if it doesn't exist
            let pageStructureModal = document.getElementById('pageStructureModal');

// Check if we're removing an existing modal first (toggle behavior)
            if (pageStructureModal && pageStructureModal.classList.contains('visible')) {
               console.log("Modal is already visible, hiding it");
               pageStructureModal.classList.remove('visible');
               pageStructureModal.style.setProperty('display', 'none', 'important');
               break;
            }

console.log("Modal exists:", !!pageStructureModal);

if (!pageStructureModal) {
               console.log("Creating new modal");
               pageStructureModal = document.createElement('div');
               pageStructureModal.id = 'pageStructureModal';
               pageStructureModal.className = 'modal-container';

// Add the modal content structure
               pageStructureModal.innerHTML = `
<div class="modal-content">
    <div class="modal-header">
        <h2>Page Structure</h2>
        <button class="close-btn" aria-label="Close">&times;</button>           
    </div>
    <div class="modal-tabs">
        <button class="tab-btn active" data-tab="headings">Headings</button>
        <button class="tab-btn" data-tab="landmarks">Landmarks</button>
        <button class="tab-btn" data-tab="links">Links</button>
    </div>
    <div class="tab-content" id="headingsContent"></div>
    <div class="tab-content hidden" id="landmarksContent"></div>
    <div class="tab-content hidden" id="linksContent"></div>
</div>
`;

document.body.appendChild(pageStructureModal);
               console.log("Modal appended to body");

// Add styles for the modal - make sure they're applied immediately
               const styleId = 'pageStructureStyles';
               let styleElement = document.getElementById(styleId);

if (!styleElement) {
                  styleElement = document.createElement('style');
                  styleElement.id = styleId;
                  styleElement.textContent = `
        .modal-container {
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background-color: rgba(0, 0, 0, 0.7);
            z-index: 9999;
            display: none;
        }
        
        .modal-container.visible {
            display: flex !important;
            justify-content: center;
            align-items: center;
        }
        
        .modal-content {
            background-color: #ffffff;
            border-radius: 5px;
            max-width: 600px;
            width: 90%;
            max-height: 80vh;
            overflow: hidden;
            display: flex;
            flex-direction: column;
            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
            border: 1px solid #333;
        }
        
        .modal-header {
            padding: 15px;
            background-color: #000000;
            color: white;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }
        
        .close-btn {
            background: none;
            border: none;
            color: white;
            font-size: 24px;
            cursor: pointer;
        }
        
        .modal-tabs {
            display: flex;
            border-bottom: 1px solid #333;
            background-color: #f0f0f0;
        }
        
        .tab-btn {
            flex: 1;
            padding: 10px;
            background: none;
            border: none;
            cursor: pointer;
            color: #000;
            font-weight: bold;
        }
        
        .tab-btn.active {
            background-color: #e0e0e0;
            border-bottom: 2px solid #000;
        }
        
        .tab-content {
            padding: 15px;
            overflow-y: auto;
            max-height: calc(80vh - 120px);
            color: #000;
            scrollbar-width: thin;
            scrollbar-color: #000 #fff;
        }
        
        /* Webkit (Chrome, Safari, Edge) scrollbar styling */
        .tab-content::-webkit-scrollbar {
            width: 10px;
        }
        
        .tab-content::-webkit-scrollbar-track {
            background: #fff;
            border: 1px solid #ddd;
        }
        
        .tab-content::-webkit-scrollbar-thumb {
            background-color: #000;
            border: 2px solid #fff;
            border-radius: 10px;
        }
        
        .tab-content::-webkit-scrollbar-thumb:hover {
            background-color: #333;
        }
        
        .tab-content.hidden {
            display: none;
        }
        
        .structure-list {
            list-style: none;
            padding: 0;
            margin: 0;
        }
        
        .heading-level-1 { margin-left: 0; }
        .heading-level-2 { margin-left: 15px; }
        .heading-level-3 { margin-left: 30px; }
        .heading-level-4 { margin-left: 45px; }
        .heading-level-5 { margin-left: 60px; }
        .heading-level-6 { margin-left: 75px; }
        
        .heading-btn, .landmark-btn, .link-btn {
            background: none;
            border: none;
            text-align: left;
            padding: 8px;
            width: 100%;
            cursor: pointer;
            color: #000;
            border-bottom: 1px solid #eee;
            white-space: normal;
            word-break: break-word;
        }
        
        .heading-btn:hover, .landmark-btn:hover, .link-btn:hover {
            background-color: #f0f0f0;
        }
        
        .element-tag {
            color: #555;
            font-family: monospace;
            font-size: 0.9em;
            border-radius: 3px;
            padding: 2px 4px;
            background-color: #f5f5f5;
            border: 1px solid #ddd;
            display: inline-block;
            margin-right: 5px;
        }
        
        .h1 { font-size: 1.5em; font-weight: bold; }
        .h2 { font-size: 1.3em; font-weight: bold; }
        .h3 { font-size: 1.1em; font-weight: bold; }
        .h4 { font-size: 1em; font-weight: bold; }
        .h5 { font-size: 0.9em; font-weight: bold; }
        .h6 { font-size: 0.8em; font-weight: bold; }
    `;
                  document.head.appendChild(styleElement);
                  console.log("Styles added to head");
               }

// Add event listeners
               const closeBtn = pageStructureModal.querySelector('.close-btn');
               closeBtn.addEventListener('click', (e) => {
                  e.preventDefault();
                  pageStructureModal.classList.remove('visible');
                  pageStructureModal.style.setProperty('display', 'none', 'important');
               });

// Tab switching functionality
               const tabBtns = pageStructureModal.querySelectorAll('.tab-btn');
               tabBtns.forEach(btn => {
                  btn.addEventListener('click', () => {
                     // Remove active class from all tabs
                     tabBtns.forEach(b => b.classList.remove('active'));
                     // Add active class to clicked tab
                     btn.classList.add('active');

// Hide all content
                     const contents = pageStructureModal.querySelectorAll('.tab-content');
                     contents.forEach(c => c.classList.add('hidden'));

// Show selected content
                     const tabName = btn.getAttribute('data-tab');
                     const contentEl = document.getElementById(`${tabName}Content`);
                     if (contentEl) {
                        contentEl.classList.remove('hidden');

// Populate content based on tab
                        if (tabName === 'headings') {
                           populateHeadings();
                        } else if (tabName === 'landmarks') {
                           populateLandmarks();
                        } else if (tabName === 'links') {
                           populateLinks();
                        }
                     } else {
                        console.error(`Content element for tab ${tabName} not found`);
                     }
                  });
               });

// Add keyboard support for modal
               pageStructureModal.addEventListener('keydown', (e) => {
                  if (e.key === 'Escape') {
                     pageStructureModal.classList.remove('visible');
                     pageStructureModal.style.setProperty('display', 'none', 'important');
                  }
               });

// Add click outside to close
               pageStructureModal.addEventListener('click', (e) => {
                  if (e.target === pageStructureModal) {
                     pageStructureModal.classList.remove('visible');
                     pageStructureModal.style.setProperty('display', 'none', 'important');
                  }
               });
            }

// Ensure modal is visible with !important to override any site styles
            console.log("Making modal visible");
            pageStructureModal.style.setProperty('display', 'flex', 'important');
            pageStructureModal.classList.add('visible');

// Force a reflow to ensure the browser applies the change
            void pageStructureModal.offsetWidth;

// Populate the content of the active tab
            console.log("Populating current tab");
            const activeTab = pageStructureModal.querySelector('.tab-btn.active');
            if (activeTab) {
               const tabName = activeTab.getAttribute('data-tab');
               console.log(`Active tab: ${tabName}`);
               if (tabName === 'headings') {
                  populateHeadings();
               } else if (tabName === 'landmarks') {
                  populateLandmarks();
               } else if (tabName === 'links') {
                  populateLinks();
               }
            } else {
               console.log("No active tab found, defaulting to headings");
               populateHeadings();
            }

break;

// Profile Section

// ✅ CASE: Blind Profile (Triggers Screen Reader & Ensures UI Updates)
         case "Blind":
            console.log("Blind Profile Activated: Triggering Screen Reader");

case "Blind-unselected":
            console.log("Blind mode deactivated. Restoring normal view.");

// ✅ Reset styles for Blind mode
            applyStylesToDocumentExceptWidget((element) => {
               element.style.filter = "";
            });

// ✅ Trigger unselected:Screen Reader to turn off the screen reader
            handleMessages({
               message: "unselected:Screen Reader"
            });

break;

// ✅ CASE: Low Vision (Triggers Multiple Features)
         case "Low Vision":
            console.log("Low Vision Profile Activated");

// ✅ CASE: Color Blind (Triggers Smart Contrast & High Saturation)
         case "Color Blind":
            console.log("Color Blind Profile Activated");

// ✅ CASE: Unselect Color Blind (Removes All Features)
         case "unselected:Color Blind":
            console.log("Color Blind Profile Deactivated");

case "unselected:Mute Sound":
            // Resume the speech synthesis if it was paused
            if (window.speechSynthesis.paused) {
               window.speechSynthesis.resume();
            }
            break;

// ✅ CASE: Seizure & Epileptic (Triggers Pause Animation & Low Saturation)
         case "Seizure & Epileptic":
            console.log("Seizure & Epileptic Profile Activated");

case "Dyslexic font":
            // Load OpenDyslexic font if not already loaded
            if (!document.getElementById("dyslexicFontStyle")) {
               const style = document.createElement("style");
               style.id = "dyslexicFontStyle";
               style.innerHTML = `
            @import url('https://fonts.cdnfonts.com/css/open-dyslexic');
        `;
               document.head.appendChild(style);

// Add a small delay to ensure the font is loaded before applying
               setTimeout(() => {
                  // Apply font to body first
                  document.body.style.setProperty("font-family", "'Open-Dyslexic', sans-serif", "important");
                  // document.body.style.setProperty("letter-spacing", "0.7rem", "important");
                  // weight will be 400 by default, so no need to set it explicitly
                  document.body.style.setProperty("font-weight", "400", "important");

// Then apply to all other elements
                  applyStylesToDocumentExceptWidget((element) => {
                     element.style.setProperty("font-family", "'Open-Dyslexic', sans-serif", "important");
                     // element.style.setProperty("letter-spacing", "0.7rem", "important");
                  });
               }, 300);
            } else {
               // Font already loaded, apply immediately
               // Apply to body first
               document.body.style.setProperty("font-family", "'Open-Dyslexic', sans-serif", "important");
               // document.body.style.setProperty("letter-spacing", "0.7rem", "important");

case "unselected:Dyslexic font":
            // Remove the dyslexic font and restore default font
            applyStylesToDocumentExceptWidget((element) => {
               element.style.removeProperty("letter-spacing");
               element.style.setProperty("font-family", "Arial, sans-serif", "important");
            });
            break;

case "Light Contrast":
            document.body.style.backgroundColor = "#FFFFFF";
            document.body.style.color = "#000000";
            document.body.style.transition = "background 0.4s, color 0.4s";

applyStylesToDocumentExceptWidget((element) => {
               if (window.getComputedStyle(element).display !== 'none' && element.innerText) {
                  element.style.backgroundColor = "#FFFFFF";
                  element.style.color = "#000000";
                  element.style.borderColor = "#000000";
                  element.classList.add("light-contrast-applied");

if (element.tagName.toLowerCase() === 'a') {
                     element.style.color = "#0073E6";
                     element.style.textDecoration = "underline";
                  }
               }
            });
            break;

case "Dark Contrast":
            document.body.style.backgroundColor = "#000000";
            document.body.style.color = "#FFFFFF";
            document.body.style.transition = "background 0.4s, color 0.4s";

applyStylesToDocumentExceptWidget((element) => {
               if (window.getComputedStyle(element).display !== 'none' && element.innerText) {
                  element.style.backgroundColor = "#000000";
                  element.style.color = "#FFFFFF";
                  element.style.borderColor = "#FFFFFF";
                  element.classList.add("dark-contrast-applied");

if (element.tagName.toLowerCase() === 'a') {
                     element.style.color = "#0000EE";
                     element.style.textDecoration = "underline";
                  }
               }
            });
            break;

// ✅ CASE: Unselect Seizure & Epileptic (Removes Both Features)
         case "unselected:Seizure & Epileptic":
            console.log("Seizure & Epileptic Profile Deactivated");

(function () {
               // ✅ Remove Pause Animation
               handleMessages({
                  data: "unselected:Pause Animation"
               });

// ✅ Remove Low Saturation
               handleMessages({
                  data: "unselected:Saturation"
               }); // Ensures saturation removal
            })();
            break;

// ✅ CASE: ADHD (Triggers Pause Animation, Reading Mask & Low Saturation)
         case "ADHD":
            console.log("ADHD Profile Activated");

(function () {
               // ✅ Apply ADHD-Specific Styles
               document.body.style.maxWidth = "";
               document.body.style.margin = "auto";
               document.body.style.lineHeight = "1.8";

// ✅ Hide Non-Essential Elements
               const nonEssentialss = document.querySelectorAll("aside, .ad, .sidebar");
               nonEssentialss.forEach((element) => (element.style.display = "none"));

// ✅ Activate Required Features
               handleMessages({
                  data: "Pause Animation"
               }); // Stop animations
               handleMessages({
                  data: "Reading Mask"
               }); // Apply reading mask
               handleMessages({
                  data: "Low Saturation"
               }); // Reduce saturation
            })();
            break;

case "unselected:ADHD":
            console.log("ADHD Profile Deactivated");

(function () {
               // ✅ Reset ADHD-Specific Styles
               document.body.style.maxWidth = "";
               document.body.style.margin = "";
               document.body.style.lineHeight = "";

// ✅ Show Non-Essential Elements
               const nonEssentialss = document.querySelectorAll("aside, .ad, .sidebar");
               nonEssentialss.forEach((element) => (element.style.display = ""));

// ✅ Remove Pause Animation
               handleMessages({
                  data: "unselected:Pause Animation"
               });

// ✅ Remove Reading Mask
               handleMessages({
                  data: "unselected:Reading Mask"
               });

// ✅ Remove Low Saturation
               handleMessages({
                  data: "unselected:Saturation"
               }); // Ensures saturation removal
            })();
            break;

// ✅ CASE: Motor Impaired (Triggers Pause Animation)
         case "Motor Impaired":
            console.log("Motor Impaired Profile Activated");

(function () {
               // ✅ Activate Pause Animation
               handleMessages({
                  data: "Pause Animation"
               }); // Stop animations
            })();
            break;

// ✅ CASE: Motor Impaired-unselected (Removes Pause Animation)
         case "Motor Impaired-unselected":
            console.log("Motor Impaired Profile Deactivated");

(function () {
               // ✅ Remove Pause Animation
               handleMessages({
                  data: "unselected:Pause Animation"
               });
            })();
            break;

// ✅ CASE: Cognitive & Learning (Triggers Smart Contrast, Bigger Text, Pause Animation & Reading Guide)
         case "Cognitive & Learning":
            console.log("Cognitive & Learning Profile Activated");

(function () {
               // ✅ Activate Required Features

handleMessages({
                  data: "Bigger Text"
               }); // Increase text size
               handleMessages({
                  data: "Pause Animation"
               }); // Stop animations
               handleMessages({
                  data: "Reading Guide"
               }); // Apply reading guide
            })();
            break;

// ✅ CASE: Cognitive & Learning-unselected (Removes All Features)
         case "Cognitive & Learning-unselected":
            console.log("Cognitive & Learning Profile Deactivated");

(function () {
               // ✅ Remove Bigger Text
               handleMessages({
                  data: "unselected:Bigger Text"
               });

// ✅ Remove Pause Animation
               handleMessages({
                  data: "unselected:Pause Animation"
               });

// ✅ Remove Reading Guide
               handleMessages({
                  data: "unselected:Reading Guide"
               });
            })();
            break;

// Reset all styles
         case "RESET":
            const elements = document.body.getElementsByTagName("*");
            Array.from(elements).forEach((element) => {
               try {
                  element.style.filter = "";
                  element.style.backgroundColor = "";
                  element.style.color = "";
                  element.style.fontSize = "";
                  element.style.letterSpacing = "";
                  element.style.lineHeight = "";
                  element.style.textAlign = "";
                  element.style.fontFamily = "";
                  element.style.animation = "";
                  element.style.transition = "";
                  element.style.cursor = "";
                  element.style.padding = "";
                  element.style.margin = "";
                  element.style.minHeight = "";
                  element.style.minWidth = "";
                  element.style.cursor = "";
                  element.style.animation = "";
                  element.style.transition = "";
                  document.body.style.backgroundColor = "";
                  document.body.style.color = "";

// UnSelect Switches and Event Section
            // Define the disableVoiceNavigation function at the top level, outside of any case blocks
            function disableVoiceNavigation() {
               const container = document.getElementById('user-aid-voice-navigation');
               if (container) {
                  // Stop speech recognition if running
                  if (window.voiceNavigationRecognition) {
                     try {
                        window.voiceNavigationRecognition.stop();
                        console.log("Speech recognition stopped");
                     } catch (e) {
                        console.error("Error stopping speech recognition:", e);
                     }
                  }

// Remove UI
                  container.remove();

// Remove number labels
                  document.querySelectorAll('.user-aid-number-label').forEach(label => label.remove());

// Remove event listeners
                  window.removeEventListener('resize', window.voiceNavigationResizeHandler);
                  window.removeEventListener('scroll', window.voiceNavigationScrollHandler);

// Clear any existing timeouts
                  if (window.scrollUpdateTimeout) {
                     clearTimeout(window.scrollUpdateTimeout);
                  }

// Reset variables
                  window.voiceNavigationActive = false;
                  window.voiceNavigationRecognition = null;

console.log("User Aid Voice Navigation completely disabled");
               }
            }

// Then in your switch statement, add the unselected case:
         case "unselected:Voice Navigation":
            console.log("🚫 Voice Navigation deactivated");
            disableVoiceNavigation();
            break;

case "unselected:Screen Reader":
    console.log("Screen Reader deactivated");
       readerActivated = false;
    // Cancel any ongoing speech
    if (window.speechSynthesis) {
        window.speechSynthesis.cancel();
    }
    
    // Remove the specific listener we stored
    if (screenReaderClickListener) {
        document.removeEventListener("click", screenReaderClickListener);
        screenReaderClickListener = null;
    }
    
    // Also update the removeTextReadListeners function to use our global reference
    function removeTextReadListeners() {
        if (screenReaderClickListener) {
            document.removeEventListener("click", screenReaderClickListener);
            screenReaderClickListener = null;
        }
    }
    
    // Call it for good measure
    removeTextReadListeners();
    break;

case "unselected:Contrast Mode":
            document.body.style.backgroundColor = "";
            document.body.style.color = "";
            document.body.style.transition = "";

applyStylesToDocumentExceptWidget((element) => {
               // Remove inline styles
               element.style.filter = "";
               element.style.backgroundColor = "";
               element.style.color = "";
               element.style.borderColor = "";
               element.style.textDecoration = "";

// Remove added classes
               element.classList.remove("light-contrast-applied");
               element.classList.remove("dark-contrast-applied");
            });
            break;

case "toggle-smart-contrast":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.filter =
                  element.style.filter === "contrast(200%)" ?
                  "contrast(100%)" :
                  "contrast(200%)";
            });
            break;

case "unselected:Bigger Text":
            console.log("Resetting text size to default");
            applyStylesToDocumentExceptWidget((element) => {
               element.style.transition = "all 0.3s ease";
               element.style.fontSize = "";
            });
            break;

case "unselected:Text Spacing":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.letterSpacing = "";
            });
            break;

case "unselected:Dyslexic Friendly":
            // Remove all dyslexic-friendly styles
            document.body.style.removeProperty("font-family");
            document.body.style.removeProperty("letter-spacing");
            document.body.style.removeProperty("font-weight");

// Remove styles from all other elements
            applyStylesToDocumentExceptWidget((element) => {
               element.style.removeProperty("font-family");
               element.style.removeProperty("letter-spacing");
            });

// Optionally remove the style element if you don't plan to use it again soon
            const dyslexicStyle = document.getElementById("dyslexicFontStyle");
            if (dyslexicStyle) {
               dyslexicStyle.remove();
            }
            break;

case "unselected:Line Height":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.lineHeight = "";
            });
            break;
         case "unselected:Highlight Links":
            document.querySelectorAll("a").forEach((link) => {
               link.style.removeProperty("background-color");
               link.style.removeProperty("color");
               link.style.removeProperty("text-decoration");

// Reset button styles if <a> is inside it
               let parentButton = link.closest("button");
               if (parentButton) {
                  parentButton.style.removeProperty("background-color");
                  parentButton.style.removeProperty("color");
               }
            });
            break;
         case "unselected:Text Align":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.textAlign = "";
            });
            break;

case "unselected:Smart Contrast":
            applyStylesToDocumentExceptWidget((element) => {
               if (element.classList.contains("smart-contrast-applied")) {
                  element.style.transition = "";
                  element.style.backgroundColor = "";
                  element.style.color = "";
                  element.style.borderColor = "";

if (element.tagName.toLowerCase() === 'a') {
                     element.style.textDecoration = "";
                     element.style.color = "";
                  }

element.classList.remove("smart-contrast-applied");
               }
            });

// Reset the document body styles as well
            document.body.style.transition = "";
            document.body.style.backgroundColor = "";
            document.body.style.color = "";
            break;

case "ADHD-unselected":
            document.body.style.maxWidth = "";
            document.body.style.margin = "";
            document.body.style.lineHeight = "";
            const nonEssentials = document.querySelectorAll("aside, .ad, .sidebar");
            nonEssentials.forEach((element) => (element.style.display = ""));
            break;

case "Color Blind-unselected":
            applyStylesToDocumentExceptWidget((element) => {
               element.style.filter = "";
               element.style.backgroundColor = "";
               element.style.color = "";
            });
            break;

case "Low Vision-unselected":
            document.body.style.fontSize = "";
            const allTexts = document.querySelectorAll("p, h1, h2, h3, span, a");
            allTexts.forEach((element) => {
               element.style.fontSize = "";
            });
            break;

case "unselected:Tooltips":
            const tooltips = document.querySelectorAll(".tooltip");
            tooltips.forEach((element) => {
               element.style.display = "";
            });
            break;

case "unselected:Reading Guide":
             // Call the cleanup function if it exists
             if (typeof window.cleanupReadingGuide === 'function') {
                window.cleanupReadingGuide();
                // After cleanup, delete the reference
                delete window.cleanupReadingGuide;
             } else {
                // Fallback cleanup if the function doesn't exist
                const readingGuide = document.getElementById("readingGuide") ||
                   document.querySelector("[id^='readingGuide_']");
 
                const readingGuideStyle = document.getElementById("readingGuideStyle") ||
                   document.querySelector("[id^='readingGuideStyle_']");
 
                // Remove the guide element
                if (readingGuide && readingGuide.parentNode) {
                   readingGuide.parentNode.removeChild(readingGuide);
                }
 
                // Remove the style element
                if (readingGuideStyle && readingGuideStyle.parentNode) {
                   readingGuideStyle.parentNode.removeChild(readingGuideStyle);
                }
 
                // Remove any event listeners that might have been added
                if (window.readingGuideMouseHandler) {
                   document.removeEventListener("mousemove", window.readingGuideMouseHandler);
                   delete window.readingGuideMouseHandler;
                }
 
                if (window.readingGuideMessageHandler) {
                   window.removeEventListener("message", window.readingGuideMessageHandler);
                   delete window.readingGuideMessageHandler;
                }
                const guideElement = document.getElementById("readingGuide");
                      // Remove the guide element
                guideElement?.remove();
 
             const guideStyle = document.getElementById("readingGuideStyle");
                if (guideStyle) guideStyle.remove();
 
                if (window.readingGuideMoveHandler) {
                   document.removeEventListener("mousemove", window.readingGuideMoveHandler);
                   delete window.readingGuideMoveHandler;
                }
 
                if (window.readingGuideObserver) {
                   window.readingGuideObserver.disconnect();
                   delete window.readingGuideObserver;
                }
 
                if (window.readingGuideInterval) {
                   clearInterval(window.readingGuideInterval);
                   delete window.readingGuideInterval;
                }
 
                document.documentElement.dataset.readingGuideActive = "false";
 
                localStorage.removeItem('readingGuideActive');
             }
 
 
             // Call removeAllFeatures to ensure any other features are also cleaned up
             removeAllFeatures();
             break;

case "Key Navigation-unselected":
            document.body.removeEventListener("keydown", handleKeyNavigation);
            break;

case "unselected:Dictionary":
            document.body.removeEventListener("dblclick", handleDictionaryLookup);
            break;

case "Page Structure-unselected":
            const structureElements = document.querySelectorAll(".page-structure");
            structureElements.forEach((element) => {
               element.style.display = "";
            });
            break;

case "unselected:Pause Animation":
                // Resume all animations (CSS and JavaScript)
                document.getAnimations().forEach(animation => animation.play());
                break;

case "Dyslexia":
            const style = document.createElement("style");
            style.innerHTML = `
                      @font-face {
                          font-family: 'OpenDyslexic';
                          src: url('https://cdn.jsdelivr.net/npm/open-dyslexic@1.0.3/fonts/OpenDyslexic-Regular.otf');
                      }
                  `;
            document.head.appendChild(style);
            document.body.style.fontFamily = "OpenDyslexic, Arial, sans-serif";
            document.body.style.lineHeight = "1.8";
            break;

default:
            console.warn(`Unhandled message: ${JSON.stringify(event.data)}`);
      }

}

async function fetchDataAndLoadWidget() {
      // Check if widget was previously hidden
      if (localStorage.getItem('widgetHidden') === 'true') {
         console.log("Widget is hidden by user preference. Not loading.");
         return; // Exit without loading the widget
      }

try {
         const dataAccountId = getQueryParam("account");
         const BASE_URL = "https://api.user-aid.com/api";
         const websiteUrl = `${BASE_URL}/website/${dataAccountId}/data`;

const response = await fetch(websiteUrl);
         if (!response.ok) {
            throw new Error("Network response was not ok");
         }
         const data = await response.json();
         console.log("API response:", data);
         widgetData = data?.widgets[0];
         websiteData = data?.website;
         widgetSettings = widgetData?.settings;
         loadWidget(widgetData);
         const iframe = document.getElementById("reactWidgetIframe");
         // Set initialization flag to true after loading widget
         setTimeout(() => {
            isWidgetInitialized = true;

// Re-apply any pending actions from localStorage if they exist
            // applyPendingActions();
            iframe.contentWindow.postMessage({
               action: "widgetLoaded",
            }, "*");
            // window.parent.postMessage({ message: "widgetLoaded" }, "*");
         }, 1000); // Give the widget a moment to fully render and stabilize
      } catch (error) {
         console.error("Failed to fetch data:", error);
      }
   }

if (document.readyState === "loading") {
      document.addEventListener("DOMContentLoaded", fetchDataAndLoadWidget);
   } else if (
      document.readyState === "interactive" ||
      document.readyState === "complete"
   ) {
      fetchDataAndLoadWidget();

} else {
      window.addEventListener("load", fetchDataAndLoadWidget);
   }
   window.addEventListener("message", handleMessages);

// Custom tab navigation
   document.addEventListener('keydown', (event) => {
       const lastChar = event.code.charAt(event.code.length - 1).toUpperCase();
        if(event.altKey && event.key !== 'Alt'){
            
          if(event.altKey && event.key == 'z' || event.altKey && event.key == 'Z'){
                  // Check if modal already exists
   const existingModal = document.getElementById("widget-hide-confirm-modal");
   if (existingModal) {
      console.log("Hide confirmation modal already open");
      return; // Exit if modal is already open
   }
                console.log("Sending shortcut key to parent:", lastChar);
                   // Create and show a confirmation modal before hiding
             const confirmModal = document.createElement("div");
             confirmModal.id = "widget-hide-confirm-modal";
             confirmModal.style.position = "fixed";
             confirmModal.style.top = "50%";
             confirmModal.style.left = "50%";
             confirmModal.style.transform = "translate(-50%, -50%)";
             confirmModal.style.backgroundColor = "#fff";
             confirmModal.style.padding = "20px";
             confirmModal.style.borderRadius = "15px"; // Increased for smoother corners like the image
             confirmModal.style.boxShadow = "0 4px 20px rgba(0,0,0,0.2)"; // Softer shadow to match the image
             confirmModal.style.zIndex = "10000";
             confirmModal.style.maxWidth = "450px";
             confirmModal.style.textAlign = "center";
             confirmModal.style.fontFamily = "Arial, sans-serif"; // Added for consistency with the image font
 
             confirmModal.innerHTML = `
         <h3 style="font-size: 18px; font-weight: bold; color: #333; margin-bottom: 15px;">HIDE ACCESSIBILITY INTERFACE?</h3>
         <p style="margin-bottom: 25px; font-size: 14px; line-height: 1.5; color: #333;">The widget will be hidden until you clear your browser data. Do you want to proceed?</p>
         <div style="display: flex; justify-content: center; gap: 15px;">
             <button id="widget-hide-confirm-ok" style="background-color: #0066cc; color: white; border: none; padding: 10px 30px; border-radius: 25px; cursor: pointer; font-size: 14px; font-weight: 500;">OK</button>
             <button id="widget-hide-confirm-cancel" style="background-color: white; color: #0066cc; border: 2px solid #0066cc; padding: 10px 30px; border-radius: 25px; cursor: pointer; font-size: 14px; font-weight: 500;">Cancel</button>
         </div>
     `;
 
             document.body.appendChild(confirmModal);
 
             // Handle OK button click
             document.getElementById("widget-hide-confirm-ok").addEventListener("click", function () {
                // Hide the interface by removing the widget iframe
                const widgetIframe1 = document.getElementById("reactWidgetIframe");
                if (widgetIframe1) {
                   // Hide instead of remove
                   widgetIframe1.style.display = "none";
                   console.log("Widget iframe hidden");
 
                   // Store hidden state in localStorage
                   localStorage.setItem('widgetHidden', 'true');
                }
 
                // Remove the confirmation modal
                document.body.removeChild(confirmModal);
             });
 
             // Handle Cancel button click
             document.getElementById("widget-hide-confirm-cancel").addEventListener("click", function () {
                // Just remove the confirmation modal
                document.body.removeChild(confirmModal);
             });
           }
          
          
            else {
                
                console.log("Sending shortcut key to parent:", lastChar);
            window.parent.postMessage({ 
                action: "shortcutKey",
                key: lastChar,
                altKey: event.altKey,
             }, "*");
             
            }
        }
       
      if (event.key === 'Tab') {
         event.preventDefault(); // Prevent default tab behavior

// Get all visible and interactive focusable elements
         const focusableElements = Array.from(document.querySelectorAll(
            'a, button, input, textarea, select, [tabindex]:not([tabindex="-1"])'
         )).filter(el => {
            // Skip elements within the widget containers
            if (el.closest("#widget-container") || el.closest("#reactWidgetIframe")) {
               return false;
            }

// Check if element or any ancestor is aria-hidden
            if (el.closest('[aria-hidden="true"]')) {
               return false;
            }

// Check computed styles for visibility
            const style = window.getComputedStyle(el);
            if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
               return false;
            }

// Check if element is disabled or has zero size
            const rect = el.getBoundingClientRect();
            return !(el.disabled || rect.width === 0 || rect.height === 0);
         });

// Get current active element and its index
         const activeElement = document.activeElement;
         const currentIndex = focusableElements.indexOf(activeElement);

// Determine direction and calculate next index
         const direction = event.shiftKey ? -1 : 1;
         let nextIndex;

if (currentIndex === -1) {
            // Start from beginning or end based on direction
            nextIndex = direction > 0 ? 0 : focusableElements.length - 1;
         } else {
            nextIndex = currentIndex + direction;

// Wrap around if out of bounds
            if (nextIndex < 0) {
               nextIndex = focusableElements.length - 1;
            } else if (nextIndex >= focusableElements.length) {
               nextIndex = 0;
            }
         }

// Clear existing outlines
         focusableElements.forEach(el => el.style.outline = '');

// Focus the next element
         const nextElement = focusableElements[nextIndex];
         if (nextElement) {
            setTimeout(() => {
               nextElement.focus({
                  preventScroll: true
               }); // Prevent immediate scroll
               nextElement.style.outline = '2px solid white';
               nextElement.style.outlineOffset = '-2px';
               nextElement.style.outlineStyle = 'solid';
               // nextElement RADIUS   
               nextElement.style.borderRadius = '20px';
               nextElement.style.padding = '5px';

// Smooth scroll after focus
               nextElement.scrollIntoView({
                  behavior: 'smooth',
                  block: 'nearest',
                  inline: 'nearest'
               });
            }, 0);
         }
      }
      // if alt + 1 then clear local storage and reload the page and open the widget
      else if (event.altKey && event.key === '1') {
         localStorage.removeItem('widgetHidden');
         location.reload();
      }
   });

})();

<=Back