☰

TypePulseX v1 - Typer for Google Docs & Slides

Types text human-like with personas, emotions, voice input, optional AI-enhanced typing mistakes, themes, soundscapes, and more.

  1. // ==UserScript==
  2. // @name         TypePulseX v1 - Typer for Google Docs & Slides
  3. // @namespace    http://tampermonkey.net/
  4. // @version      1
  5. // @description  Types text human-like with personas, emotions, voice input, optional AI-enhanced typing mistakes, themes, soundscapes, and more.
  6. // @author       AWarrior (Reviewed by and written by Reehee)
  7. // @match        https://docs.google.com/document/d/*
  8. // @match        https://docs.google.com/presentation/d/*
  9. // @icon         https://i.imgur.com/nwFO7Ff.png
  10. // @grant        GM_addStyle
  11. // @grant        GM_xmlhttpRequest
  12. // @grant        GM_setValue
  13. // @grant        GM_getValue
  14. // @require      https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js
  15. // @license      MIT
  16. // ==/UserScript==
  17.  
  18. (function() {
  19.     'use strict';
  20.  
  21.     // --- Configuration ---
  22.     const DEFAULT_API_KEY = 'Enter your personal API Key here. DO NOT PUBLISH YOUR APIKEY PLEASE. FOR GODS SAKE DONT DO IT.';
  23.     let API_KEY = GM_getValue('typePulseXApiKey', DEFAULT_API_KEY);
  24.     const TYPING_SOUND_URL = 'https://www.soundjay.com/buttons/beep-01a.mp3';
  25.     const DEFAULT_SETTINGS = {
  26.         lowerBound: 60,
  27.         upperBound: 140,
  28.         typoRatePercent: 5,
  29.         enableTypos: true,
  30.         useAdvancedAlgorithm: true,
  31.         enableSentencePauses: false,
  32.         sentencePauseDurationMinutes: 1,
  33.         persona: 'procrastinator',
  34.         emotion: 'neutral',
  35.         theme: 'light',
  36.         soundscape: 'typewriter',
  37.         aiFillerFreq: 0.1,
  38.         aiTypingEnhance: true,
  39.         speedMultiplier: 1.0,
  40.         cursorBlink: true,
  41.         fontSize: 14,
  42.         customColor: '#007AFF',
  43.         enableSound: true,
  44.         enableHaptics: false,
  45.         autoSave: true,
  46.         gamifiedStats: true,
  47.         enableAI: true,
  48.         maxTypoLength: 3,
  49.         typoCharDelayMs: 50,
  50.         typoPreBackspaceDelayMs: 150,
  51.         backspaceDelayMs: 90,
  52.         advSpaceMin: 1.8,
  53.         advSpaceMax: 2.8,
  54.         advWordEndMin: 1.1,
  55.         advWordEndMax: 1.5,
  56.         advPunctuationMultiplier: 1.3,
  57.         advRandomPauseChance: 0.02,
  58.         advRandomPauseMinMs: 150,
  59.         advRandomPauseMaxMs: 400,
  60.         advTypoRecognitionMinMs: 250,
  61.         advTypoRecognitionMaxMs: 800,
  62.         advBackspaceDelayMs: 100,
  63.         sentencePauseProbability: 0.5,
  64.         punctuationPauseMinMs: 500,
  65.         punctuationPauseMaxMs: 1000,
  66.         modeSwitchProbability: 0.05,
  67.         fastModeFactor: 0.8,
  68.         slowModeFactor: 1.2
  69.     };
  70.  
  71.     const PERSONAS = {
  72.         procrastinator: { typoRateMultiplier: 1.2, pauseFreqMultiplier: 1.5, aiPrompt: 'casual, hesitant tone', quirk: 'ugh', aiTypoStyle: 'random pauses' },
  73.         overthinker: { typoRateMultiplier: 0.8, pauseFreqMultiplier: 1.2, aiPrompt: 'analytical, cautious tone', backspaceFreq: 0.5, quirk: 'hmm', aiTypoStyle: 'frequent backspaces' },
  74.         multitasker: { typoRateMultiplier: 1.0, pauseFreqMultiplier: 1.8, aiPrompt: 'distracted, abrupt tone', quirk: 'brb', aiTypoStyle: 'missed letters' },
  75.         rookie: { typoRateMultiplier: 1.5, pauseFreqMultiplier: 0.8, aiPrompt: 'clumsy, eager tone', quirk: 'oops', aiTypoStyle: 'extra letters' },
  76.         poet: { typoRateMultiplier: 0.5, pauseFreqMultiplier: 1.0, aiPrompt: 'lyrical, dramatic tone', quirk: 'alas', aiTypoStyle: 'subtle hesitations' }
  77.     };
  78.  
  79.     const EMOTIONS = {
  80.         frustrated: { typoRateMultiplier: 1.5, pauseFreqMultiplier: 1.2, speedMod: 1.2, aiPrompt: 'angry, rushed tone', quirk: 'argh' },
  81.         excited: { typoRateMultiplier: 0.8, pauseFreqMultiplier: 0.8, speedMod: 0.8, aiPrompt: 'energetic, upbeat tone', quirk: '!!' },
  82.         bored: { typoRateMultiplier: 1.0, pauseFreqMultiplier: 1.5, speedMod: 1.5, aiPrompt: 'lazy, monotone tone', quirk: 'zzz' },
  83.         neutral: { typoRateMultiplier: 1.0, pauseFreqMultiplier: 1.0, speedMod: 1.0, aiPrompt: 'neutral tone', quirk: '' },
  84.         inspired: { typoRateMultiplier: 0.6, pauseFreqMultiplier: 0.9, speedMod: 0.9, aiPrompt: 'creative, flowing tone', quirk: 'wow' }
  85.     };
  86.  
  87.     const SOUNDSCAPES = {
  88.         typewriter: 'https://www.soundjay.com/mechanical/typewriter-key-1.mp3',
  89.         keyboard: 'https://www.soundjay.com/buttons/beep-01a.mp3',
  90.         rain: 'https://www.soundjay.com/nature/rain-01.mp3',
  91.         none: null
  92.     };
  93.  
  94.     // --- State Variables ---
  95.     let settings = GM_getValue('typePulseXSettings', DEFAULT_SETTINGS);
  96.     let cancelTyping = false;
  97.     let typingInProgress = false;
  98.     let overlayElement = null;
  99.     let infoPopupElement = null;
  100.     let settingsPopupElement = null;
  101.     let isFastMode = false;
  102.     let stats = { time: 0, errors: 0, chars: 0, aiCalls: 0 };
  103.     let inputHistory = [];
  104.  
  105.     // --- CSS with Enhanced Dragging, Color Matching, and Aesthetics ---
  106.     GM_addStyle(`
  107.         .taqtaq-overlay, .taqtaq-settings {
  108.             position: fixed; padding: 20px; border-radius: 16px; box-shadow: 0 10px 30px rgba(0, 0, 0, 0.15); z-index: 10000;
  109.             display: flex; flex-direction: column; width: 360px; font-family: 'Helvetica Neue', sans-serif; font-size: ${settings.fontSize}px;
  110.             transform: scale(0); opacity: 0; transition: all 0.3s ease-out; background: ${settings.customColor}22; color: #333;
  111.             will-change: transform, top, left; /* Optimize dragging */
  112.         }
  113.         .taqtaq-overlay.active, .taqtaq-settings.active { transform: scale(1); opacity: 1; animation: bounceIn 0.5s ease-out; }
  114.         @keyframes bounceIn {
  115.             0% { transform: scale(0.8); opacity: 0; }
  116.             60% { transform: scale(1.05); opacity: 1; }
  117.             100% { transform: scale(1); }
  118.         }
  119.         .taqtaq-header {
  120.             padding: 12px 16px; cursor: move; border-bottom: 1px solid ${settings.customColor}44; border-radius: 16px 16px 0 0;
  121.             display: flex; justify-content: space-between; align-items: center; user-select: none; background: linear-gradient(to bottom, ${settings.customColor}33, ${settings.customColor}22);
  122.         }
  123.         .taqtaq-header-title { font-weight: 600; font-size: 16px; color: ${settings.customColor}; text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1); }
  124.         .taqtaq-header-title small { font-size: 12px; color: #777; display: block; margin-top: 2px; }
  125.         .taqtaq-info-icon {
  126.             cursor: pointer; font-style: normal; font-weight: bold; color: ${settings.customColor}; border: 2px solid ${settings.customColor};
  127.             border-radius: 50%; width: 22px; height: 22px; display: inline-flex; justify-content: center; align-items: center; font-size: 12px;
  128.             transition: transform 0.2s; background: #fff;
  129.         }
  130.         .taqtaq-info-icon:hover { transform: scale(1.1); }
  131.         .taqtaq-close-btn {
  132.             cursor: pointer; font-size: 24px; color: #888; transition: color 0.2s, transform 0.2s;
  133.         }
  134.         .taqtaq-close-btn:hover { color: #ff4444; transform: scale(1.1); }
  135.         .taqtaq-content { padding: 20px; display: flex; flex-direction: column; gap: 18px; }
  136.         .taqtaq-overlay textarea {
  137.             width: 100%; padding: 12px; border-radius: 10px; resize: vertical; box-sizing: border-box; min-height: 120px; font-size: ${settings.fontSize}px;
  138.             border: 1px solid ${settings.customColor}44; transition: border-color 0.3s, box-shadow 0.3s; background: #fff; color: #333;
  139.             box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.05);
  140.         }
  141.         .taqtaq-overlay textarea:focus { border-color: ${settings.customColor}; box-shadow: 0 0 8px ${settings.customColor}44; outline: none; }
  142.         .taqtaq-input-group { display: flex; gap: 12px; align-items: center; }
  143.         .taqtaq-input-group label { flex-basis: 60px; font-weight: 500; color: #555; }
  144.         .taqtaq-input-group input[type="number"], .taqtaq-settings input[type="number"], .taqtaq-settings input[type="text"] {
  145.             width: 70px; padding: 8px; border-radius: 8px; border: 1px solid ${settings.customColor}44; font-size: 13px; transition: all 0.3s;
  146.             background: #fff; color: #333; box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.05);
  147.         }
  148.         .taqtaq-input-group input:focus { border-color: ${settings.customColor}; box-shadow: 0 0 6px ${settings.customColor}44; outline: none; }
  149.         .taqtaq-input-group input[type="checkbox"] {
  150.             appearance: none; width: 18px; height: 18px; border: 2px solid ${settings.customColor}; border-radius: 4px; cursor: pointer;
  151.             transition: background-color 0.2s; background: #fff;
  152.         }
  153.         .taqtaq-input-group input[type="checkbox"]:checked { background: ${settings.customColor}; }
  154.         .taqtaq-input-group input[type="checkbox"]:hover { box-shadow: 0 0 4px ${settings.customColor}44; }
  155.         .taqtaq-options-group { display: flex; flex-direction: column; gap: 12px; }
  156.         .taqtaq-checkbox-item { display: flex; align-items: center; gap: 12px; }
  157.         .taqtaq-checkbox-item label { font-size: 13px; }
  158.         .taqtaq-eta, .taqtaq-stats { font-size: 12px; color: #888; text-align: center; font-style: italic; }
  159.         .taqtaq-buttons { display: flex; justify-content: flex-end; gap: 12px; margin-top: 16px; }
  160.         .taqtaq-button {
  161.             padding: 10px 20px; border: none; border-radius: 10px; cursor: pointer; font-size: 14px; background: ${settings.customColor};
  162.             color: #fff; box-shadow: 0 3px 10px ${settings.customColor}44; transition: all 0.3s ease; font-weight: 500;
  163.         }
  164.         .taqtaq-button:hover { transform: translateY(-3px); box-shadow: 0 6px 14px ${settings.customColor}66; }
  165.         .taqtaq-cancel-button { background: #666; }
  166.         .taqtaq-info-popup {
  167.             position: absolute; border: 1px solid ${settings.customColor}44; border-radius: 12px; box-shadow: 0 6px 12px rgba(0,0,0,0.2); padding: 16px; max-width: 400px; z-index: 10001;
  168.             background: ${settings.customColor}22; color: #333; transform: scale(0); opacity: 0; transition: all 0.3s;
  169.         }
  170.         .taqtaq-info-popup.active { transform: scale(1); opacity: 1; animation: popIn 0.4s ease-out; }
  171.         @keyframes popIn { 0% { transform: scale(0.7); opacity: 0; } 100% { transform: scale(1); opacity: 1; } }
  172.         .taqtaq-overlay.dark { background: #1C1C1E; color: #E5E5E7; }
  173.         .taqtaq-overlay.light { background: ${settings.customColor}22; color: #333; }
  174.         .taqtaq-overlay.retro { background: #000; color: #0f0; font-family: 'Courier New', monospace; }
  175.         .taqtaq-overlay.dark .taqtaq-header { background: linear-gradient(to bottom, #2C2C2E, #1C1C1E); }
  176.         .taqtaq-overlay.light .taqtaq-header { background: linear-gradient(to bottom, ${settings.customColor}33, ${settings.customColor}22); }
  177.         .taqtaq-overlay.retro .taqtaq-header { background: linear-gradient(to bottom, #111, #000); }
  178.         .taqtaq-overlay.dark textarea, .taqtaq-overlay.dark input[type="number"], .taqtaq-overlay.dark input[type="checkbox"] { background: #2C2C2E; color: #E5E5E7; border: 1px solid #444; }
  179.         .taqtaq-overlay.light textarea, .taqtaq-overlay.light input[type="number"], .taqtaq-overlay.light input[type="checkbox"] { background: #fff; color: #333; border: 1px solid ${settings.customColor}44; }
  180.         .taqtaq-overlay.retro textarea, .taqtaq-overlay.retro input[type="number"], .taqtaq-overlay.retro input[type="checkbox"] { background: #111; color: #0f0; border: 1px solid #0f0; }
  181.         .taqtaq-tab-bar { display: flex; gap: 10px; margin-bottom: 15px; border-bottom: 2px solid ${settings.customColor}44; background: ${settings.customColor}11; padding: 5px; border-radius: 8px; }
  182.         .taqtaq-tab { padding: 8px 15px; cursor: pointer; border-bottom: 2px solid transparent; transition: all 0.3s; color: #666; border-radius: 6px; }
  183.         .taqtaq-tab.active { border-bottom-color: ${settings.customColor}; color: ${settings.customColor}; background: ${settings.customColor}22; }
  184.         .taqtaq-tab:hover { color: ${settings.customColor}; background: ${settings.customColor}11; }
  185.         .taqtaq-settings-content { padding: 15px; flex-grow: 1; overflow-y: auto; border-radius: 0 0 16px 16px; }
  186.         .blink { animation: blink 0.5s infinite; }
  187.         @keyframes blink { 50% { opacity: 0; } }
  188.     `);
  189.  
  190.     // --- Main Logic ---
  191.     function initializeScript() {
  192.         console.log('TypePulseX v3.5 initializing...');
  193.         try {
  194.             insertButtons();
  195.         } catch (e) {
  196.             console.error('Initialization error:', e);
  197.         }
  198.     }
  199.  
  200.     function insertButtons() {
  201.         const extensionsMenu = document.getElementById('docs-extensions-menu');
  202.         if (!extensionsMenu || document.getElementById('typepulsex-button')) return;
  203.  
  204.         const typePulseButton = createButton('TypePulseX', 'typepulsex-button');
  205.         typePulseButton.addEventListener('click', handleTaqtaqClick);
  206.         const stopButton = createButton('Stop', 'stop-button', true);
  207.         stopButton.style.color = 'red';
  208.         stopButton.addEventListener('click', handleStopClick);
  209.  
  210.         try {
  211.             console.log('Inserting buttons into Extensions menu...');
  212.             extensionsMenu.parentNode.insertBefore(typePulseButton, extensionsMenu.nextSibling);
  213.             typePulseButton.parentNode.insertBefore(stopButton, typePulseButton.nextSibling);
  214.             console.log('Buttons inserted successfully.');
  215.         } catch (e) {
  216.             console.error('Error inserting buttons:', e);
  217.         }
  218.     }
  219.  
  220.     function createButton(text, id, hidden = false) {
  221.         const button = document.createElement('div');
  222.         button.textContent = text;
  223.         button.classList.add('menu-button', 'goog-control', 'goog-inline-block');
  224.         button.style.userSelect = 'none';
  225.         button.style.cursor = 'pointer';
  226.         button.id = id;
  227.         if (hidden) button.style.display = 'none';
  228.         return button;
  229.     }
  230.  
  231.     function handleTaqtaqClick() {
  232.         console.log('TypePulseX button clicked.');
  233.         if (typingInProgress) {
  234.             const stopButton = document.getElementById('stop-button');
  235.             if (stopButton) {
  236.                 stopButton.classList.add('blink');
  237.                 setTimeout(() => stopButton.classList.remove('blink'), 1000);
  238.             }
  239.             return;
  240.         }
  241.         showOverlay();
  242.     }
  243.  
  244.     function handleStopClick() {
  245.         if (typingInProgress) {
  246.             cancelTyping = true;
  247.             const stopButton = document.getElementById('stop-button');
  248.             if (stopButton) stopButton.textContent = 'Stopping...';
  249.         }
  250.     }
  251.  
  252.     function showOverlay() {
  253.         console.log('Attempting to show overlay...');
  254.         if (overlayElement) {
  255.             console.log('Overlay exists, showing it.');
  256.             overlayElement.style.display = 'flex';
  257.             overlayElement.classList.add('active');
  258.             updateUIColor();
  259.             return;
  260.         }
  261.  
  262.         try {
  263.             overlayElement = document.createElement('div');
  264.             overlayElement.classList.add('taqtaq-overlay', settings.theme);
  265.  
  266.             const header = document.createElement('div');
  267.             header.classList.add('taqtaq-header');
  268.             const title = document.createElement('div');
  269.             title.classList.add('taqtaq-header-title');
  270.             const titleText = document.createElement('span');
  271.             titleText.textContent = 'TypePulseX v3.5';
  272.             const subtitle = document.createElement('small');
  273.             subtitle.textContent = 'by reehee';
  274.             title.appendChild(titleText);
  275.             title.appendChild(document.createElement('br'));
  276.             title.appendChild(subtitle);
  277.  
  278.             const iconsContainer = document.createElement('div');
  279.             iconsContainer.style.display = 'flex';
  280.             iconsContainer.style.gap = '10px';
  281.             const infoIcon = document.createElement('i');
  282.             infoIcon.classList.add('taqtaq-info-icon');
  283.             infoIcon.textContent = 'i';
  284.             infoIcon.addEventListener('click', toggleInfoPopup);
  285.             const closeBtn = document.createElement('span');
  286.             closeBtn.classList.add('taqtaq-close-btn');
  287.             closeBtn.textContent = '×';
  288.             closeBtn.addEventListener('click', () => overlayElement.style.display = 'none');
  289.             iconsContainer.appendChild(infoIcon);
  290.             iconsContainer.appendChild(closeBtn);
  291.             header.appendChild(title);
  292.             header.appendChild(iconsContainer);
  293.             overlayElement.appendChild(header);
  294.  
  295.             const content = document.createElement('div');
  296.             content.classList.add('taqtaq-content');
  297.  
  298.             const textField = document.createElement('textarea');
  299.             textField.placeholder = 'Type, paste, or speak your text...';
  300.             const voiceButton = document.createElement('button');
  301.             voiceButton.textContent = 'Voice Input';
  302.             voiceButton.classList.add('taqtaq-button');
  303.             voiceButton.addEventListener('click', () => handleVoiceInput(textField));
  304.             const etaLabel = document.createElement('div');
  305.             etaLabel.classList.add('taqtaq-eta');
  306.             const statsLabel = document.createElement('div');
  307.             statsLabel.classList.add('taqtaq-stats');
  308.             statsLabel.textContent = 'Speed: 0 chars/sec | Errors: 0 | AI Calls: 0';
  309.  
  310.             const buttons = document.createElement('div');
  311.             buttons.classList.add('taqtaq-buttons');
  312.             const settingsButton = document.createElement('button');
  313.             settingsButton.textContent = 'Settings';
  314.             settingsButton.classList.add('taqtaq-button');
  315.             settingsButton.addEventListener('click', showSettingsPopup);
  316.             const confirmButton = document.createElement('button');
  317.             confirmButton.textContent = 'Start Typing';
  318.             confirmButton.classList.add('taqtaq-button', 'taqtaq-confirm-button');
  319.             confirmButton.addEventListener('click', () => startTypingProcess(textField));
  320.             buttons.appendChild(settingsButton);
  321.             buttons.appendChild(confirmButton);
  322.  
  323.             content.appendChild(textField);
  324.             content.appendChild(voiceButton);
  325.             content.appendChild(etaLabel);
  326.             content.appendChild(statsLabel);
  327.             content.appendChild(buttons);
  328.             overlayElement.appendChild(content);
  329.  
  330.             document.body.appendChild(overlayElement);
  331.             overlayElement.style.left = `${Math.max(0, (window.innerWidth - overlayElement.offsetWidth) / 2)}px`;
  332.             overlayElement.style.top = `${Math.max(0, (window.innerHeight - overlayElement.offsetHeight) / 2)}px`;
  333.             setTimeout(() => overlayElement.classList.add('active'), 10);
  334.             makeDraggable(overlayElement, header);
  335.             updateEta(etaLabel, textField);
  336.             textField.addEventListener('input', () => updateEta(etaLabel, textField));
  337.             console.log('Overlay created and appended.');
  338.         } catch (e) {
  339.             console.error('Error creating overlay:', e);
  340.         }
  341.     }
  342.  
  343.     // --- Settings Popup ---
  344.     function showSettingsPopup() {
  345.         console.log('Attempting to show settings popup...');
  346.         if (settingsPopupElement) {
  347.             settingsPopupElement.style.display = 'flex';
  348.             settingsPopupElement.classList.add('active');
  349.             updateUIColor();
  350.             return;
  351.         }
  352.  
  353.         settingsPopupElement = document.createElement('div');
  354.         settingsPopupElement.classList.add('taqtaq-settings', settings.theme);
  355.         settingsPopupElement.style.left = '60%';
  356.         settingsPopupElement.style.top = '50%';
  357.         settingsPopupElement.style.transform = 'translate(-50%, -50%)';
  358.  
  359.         const header = document.createElement('div');
  360.         header.classList.add('taqtaq-header');
  361.         const title = document.createElement('div');
  362.         title.classList.add('taqtaq-header-title');
  363.         title.appendChild(document.createElement('span')).textContent = 'Settings';
  364.         title.appendChild(document.createElement('small')).textContent = 'Customize Your Typer';
  365.         const closeBtn = document.createElement('span');
  366.         closeBtn.classList.add('taqtaq-close-btn');
  367.         closeBtn.textContent = '×';
  368.         closeBtn.addEventListener('click', () => settingsPopupElement.style.display = 'none');
  369.         header.appendChild(title);
  370.         header.appendChild(closeBtn);
  371.  
  372.         const tabBar = document.createElement('div');
  373.         tabBar.classList.add('taqtaq-tab-bar');
  374.         const tabs = [
  375.             { id: 'typing', label: 'Typing' },
  376.             { id: 'ai', label: 'AI' },
  377.             { id: 'ui', label: 'UI' }
  378.         ];
  379.         tabs.forEach(tab => {
  380.             const tabElement = document.createElement('div');
  381.             tabElement.classList.add('taqtaq-tab');
  382.             tabElement.textContent = tab.label;
  383.             tabElement.dataset.tab = tab.id;
  384.             tabElement.addEventListener('click', () => switchTab(tab.id));
  385.             tabBar.appendChild(tabElement);
  386.         });
  387.  
  388.         const content = document.createElement('div');
  389.         content.classList.add('taqtaq-settings-content');
  390.         content.appendChild(createTypingSettings());
  391.         content.appendChild(createAISettings());
  392.         content.appendChild(createUISettings());
  393.         switchTab('typing');
  394.  
  395.         const saveButton = document.createElement('button');
  396.         saveButton.textContent = 'Save';
  397.         saveButton.classList.add('taqtaq-button', 'taqtaq-confirm-button');
  398.         saveButton.addEventListener('click', () => {
  399.             saveSettings();
  400.             settingsPopupElement.style.display = 'none';
  401.         });
  402.  
  403.         settingsPopupElement.appendChild(header);
  404.         settingsPopupElement.appendChild(tabBar);
  405.         settingsPopupElement.appendChild(content);
  406.         settingsPopupElement.appendChild(saveButton);
  407.         document.body.appendChild(settingsPopupElement);
  408.         setTimeout(() => settingsPopupElement.classList.add('active'), 10);
  409.         makeDraggable(settingsPopupElement, header);
  410.         console.log('Settings popup created and appended.');
  411.     }
  412.  
  413.     function switchTab(tabId) {
  414.         const tabs = settingsPopupElement.querySelectorAll('.taqtaq-tab');
  415.         const contents = settingsPopupElement.querySelectorAll('.taqtaq-settings-tab');
  416.         tabs.forEach(tab => tab.classList.toggle('active', tab.dataset.tab === tabId));
  417.         contents.forEach(content => content.style.display = content.id === `tab-${tabId}` ? 'block' : 'none');
  418.     }
  419.  
  420.     function createTypingSettings() {
  421.         const tab = document.createElement('div');
  422.         tab.id = 'tab-typing';
  423.         tab.classList.add('taqtaq-settings-tab');
  424.         tab.appendChild(createInputGroup('Speed Min (ms)', 'number', settings.lowerBound, val => { settings.lowerBound = val; }));
  425.         tab.appendChild(createInputGroup('Speed Max (ms)', 'number', settings.upperBound, val => { settings.upperBound = val; }));
  426.         tab.appendChild(createInputGroup('Typos (%)', 'number', settings.typoRatePercent, val => { settings.typoRatePercent = val; }));
  427.         tab.appendChild(createInputGroup('Enable Typos', 'checkbox', settings.enableTypos, val => { settings.enableTypos = val; }));
  428.         tab.appendChild(createInputGroup('Advanced Rhythm', 'checkbox', settings.useAdvancedAlgorithm, val => { settings.useAdvancedAlgorithm = val; }));
  429.         tab.appendChild(createInputGroup('Sentence Pauses', 'checkbox', settings.enableSentencePauses, val => { settings.enableSentencePauses = val; }));
  430.         tab.appendChild(createInputGroup('Pause Duration (min)', 'number', settings.sentencePauseDurationMinutes, val => { settings.sentencePauseDurationMinutes = val; }));
  431.         tab.appendChild(createInputGroup('Persona', 'select', settings.persona, val => { settings.persona = val; }, Object.keys(PERSONAS)));
  432.         tab.appendChild(createInputGroup('Emotion', 'select', settings.emotion, val => { settings.emotion = val; }, Object.keys(EMOTIONS)));
  433.         return tab;
  434.     }
  435.  
  436.     function createAISettings() {
  437.         const tab = document.createElement('div');
  438.         tab.id = 'tab-ai';
  439.         tab.classList.add('taqtaq-settings-tab');
  440.         tab.style.display = 'none';
  441.         tab.appendChild(createInputGroup('Enable AI', 'checkbox', settings.enableAI, val => {
  442.             if (val && API_KEY === DEFAULT_API_KEY) {
  443.                 alert('Please input an API Key to be able to run this part of the program. (Sorry I’d love to give you all this myself but it’s just not possible.) Also make sure to get an API Key from OpenAI, it will work the best. Note: This feature is in beta, so it’s not perfect—don’t expect miracles!');
  444.                 settings.enableAI = false;
  445.             } else {
  446.                 settings.enableAI = val;
  447.             }
  448.         }));
  449.         tab.appendChild(createInputGroup('AI Typing Enhance', 'checkbox', settings.aiTypingEnhance, val => {
  450.             if (val && API_KEY === DEFAULT_API_KEY) {
  451.                 alert('Please input an API Key to be able to run this part of the program. (Sorry I’d love to give you all this myself but it’s just not possible.) Also make sure to get an API Key from OpenAI, it will work the best. Note: This feature is in beta, so it’s not perfect—don’t expect miracles!');
  452.                 settings.aiTypingEnhance = false;
  453.             } else {
  454.                 settings.aiTypingEnhance = val;
  455.             }
  456.         }));
  457.         tab.appendChild(createInputGroup('AI Filler Freq (%)', 'number', settings.aiFillerFreq * 100, val => { settings.aiFillerFreq = val / 100; }));
  458.         tab.appendChild(createInputGroup('API Key', 'text', API_KEY, val => {
  459.             API_KEY = val || DEFAULT_API_KEY;
  460.             GM_setValue('typePulseXApiKey', API_KEY);
  461.             console.log('API Key updated to:', API_KEY);
  462.         }));
  463.         const note = document.createElement('p');
  464.         note.textContent = 'Note: Input your OpenAI API key here and DO NOT SHARE IT WITH ANYONE!';
  465.         note.style.fontSize = '12px';
  466.         note.style.color = '#ff4444';
  467.         tab.appendChild(note);
  468.         return tab;
  469.     }
  470.  
  471.     function createUISettings() {
  472.         const tab = document.createElement('div');
  473.         tab.id = 'tab-ui';
  474.         tab.classList.add('taqtaq-settings-tab');
  475.         tab.style.display = 'none';
  476.         tab.appendChild(createInputGroup('Theme', 'select', settings.theme, val => { settings.theme = val; }, ['dark', 'light', 'retro']));
  477.         tab.appendChild(createInputGroup('Soundscape', 'select', settings.soundscape, val => { settings.soundscape = val; }, Object.keys(SOUNDSCAPES)));
  478.         tab.appendChild(createInputGroup('Font Size (px)', 'number', settings.fontSize, val => { settings.fontSize = val; }));
  479.         tab.appendChild(createInputGroup('Custom Color', 'color', settings.customColor, val => { settings.customColor = val; }));
  480.         tab.appendChild(createInputGroup('Cursor Blink', 'checkbox', settings.cursorBlink, val => { settings.cursorBlink = val; }));
  481.         tab.appendChild(createInputGroup('Enable Sound', 'checkbox', settings.enableSound, val => { settings.enableSound = val; }));
  482.         tab.appendChild(createInputGroup('Enable Haptics', 'checkbox', settings.enableHaptics, val => { settings.enableHaptics = val; }));
  483.         tab.appendChild(createInputGroup('Auto-Save', 'checkbox', settings.autoSave, val => { settings.autoSave = val; }));
  484.         tab.appendChild(createInputGroup('Gamified Stats', 'checkbox', settings.gamifiedStats, val => { settings.gamifiedStats = val; }));
  485.         return tab;
  486.     }
  487.  
  488.     function createInputGroup(labelText, type, value, onChange, options = null) {
  489.         const group = document.createElement('div');
  490.         group.classList.add('taqtaq-input-group');
  491.         const label = document.createElement('label');
  492.         label.textContent = labelText;
  493.         let input;
  494.  
  495.         if (type === 'select') {
  496.             input = document.createElement('select');
  497.             options.forEach(opt => {
  498.                 const option = document.createElement('option');
  499.                 option.value = opt;
  500.                 option.textContent = opt.charAt(0).toUpperCase() + opt.slice(1);
  501.                 input.appendChild(option);
  502.             });
  503.             input.value = value;
  504.         } else {
  505.             input = document.createElement('input');
  506.             input.type = type;
  507.             if (type === 'checkbox') input.checked = value;
  508.             else input.value = value;
  509.         }
  510.  
  511.         input.addEventListener('change', () => {
  512.             if (type === 'checkbox') onChange(input.checked);
  513.             else if (type === 'number') onChange(parseFloat(input.value) || 0);
  514.             else onChange(input.value);
  515.         });
  516.         group.appendChild(label);
  517.         group.appendChild(input);
  518.         return group;
  519.     }
  520.  
  521.     function saveSettings() {
  522.         GM_setValue('typePulseXSettings', settings);
  523.         updateTheme();
  524.         updateUIColor();
  525.         if (overlayElement) {
  526.             overlayElement.querySelector('textarea').style.fontSize = `${settings.fontSize}px`;
  527.         }
  528.     }
  529.  
  530.     function updateEta(etaLabel, textField) {
  531.         const charCount = textField.value.length;
  532.         const low = settings.lowerBound;
  533.         const high = settings.upperBound;
  534.         if (charCount > 0 && low >= 0 && high >= low) {
  535.             let baseMs = charCount * ((low + high) / 2);
  536.             if (settings.enableTypos) baseMs += charCount * (settings.typoRatePercent / 100) * 500;
  537.             const etaMinutes = Math.ceil(baseMs / 60000);
  538.             etaLabel.textContent = `ETA: ~${etaMinutes} min`;
  539.         } else {
  540.             etaLabel.textContent = '';
  541.         }
  542.     }
  543.  
  544.     function updateTheme() {
  545.         if (overlayElement) overlayElement.classList.replace(overlayElement.classList[1], settings.theme);
  546.         if (settingsPopupElement) settingsPopupElement.classList.replace(settingsPopupElement.classList[1], settings.theme);
  547.     }
  548.  
  549.     function updateUIColor() {
  550.         GM_addStyle(`
  551.             .taqtaq-overlay, .taqtaq-settings { background: ${settings.customColor}22; }
  552.             .taqtaq-header { background: linear-gradient(to bottom, ${settings.customColor}33, ${settings.customColor}22); border-bottom-color: ${settings.customColor}44; }
  553.             .taqtaq-header-title { color: ${settings.customColor}; }
  554.             .taqtaq-info-icon { color: ${settings.customColor}; border-color: ${settings.customColor}; }
  555.             .taqtaq-button { background: ${settings.customColor}; box-shadow: 0 3px 10px ${settings.customColor}44; }
  556.             .taqtaq-button:hover { box-shadow: 0 6px 14px ${settings.customColor}66; }
  557.             .taqtaq-overlay textarea, .taqtaq-settings input[type="number"], .taqtaq-settings input[type="text"] { border-color: ${settings.customColor}44; }
  558.             .taqtaq-overlay textarea:focus, .taqtaq-settings input:focus { border-color: ${settings.customColor}; box-shadow: 0 0 6px ${settings.customColor}44; }
  559.             .taqtaq-input-group input[type="checkbox"] { border-color: ${settings.customColor}; }
  560.             .taqtaq-input-group input[type="checkbox"]:checked { background: ${settings.customColor}; }
  561.             .taqtaq-input-group input[type="checkbox"]:hover { box-shadow: 0 0 4px ${settings.customColor}44; }
  562.             .taqtaq-tab-bar { border-bottom-color: ${settings.customColor}44; background: ${settings.customColor}11; }
  563.             .taqtaq-tab.active { border-bottom-color: ${settings.customColor}; color: ${settings.customColor}; background: ${settings.customColor}22; }
  564.             .taqtaq-tab:hover { color: ${settings.customColor}; background: ${settings.customColor}11; }
  565.             .taqtaq-info-popup { background: ${settings.customColor}22; border-color: ${settings.customColor}44; }
  566.         `);
  567.     }
  568.  
  569.     function toggleInfoPopup(event) {
  570.         if (infoPopupElement) hideInfoPopup();
  571.         else showInfoPopup(event.target);
  572.         event.stopPropagation();
  573.     }
  574.  
  575.     function showInfoPopup(iconElement) {
  576.         try {
  577.             hideInfoPopup();
  578.             infoPopupElement = document.createElement('div');
  579.             infoPopupElement.classList.add('taqtaq-info-popup');
  580.             const p = document.createElement('p');
  581.             const strong = document.createElement('strong');
  582.             strong.textContent = 'Instructions:';
  583.             p.appendChild(strong);
  584.             const ul = document.createElement('ul');
  585.             [
  586.                 'Enter text or use voice input.',
  587.                 'Adjust settings via Settings button.',
  588.                 'Click "Start Typing" to begin.',
  589.                 'Keep tab active for best results.'
  590.             ].forEach(text => {
  591.                 const li = document.createElement('li');
  592.                 li.textContent = text;
  593.                 ul.appendChild(li);
  594.             });
  595.             infoPopupElement.appendChild(p);
  596.             infoPopupElement.appendChild(ul);
  597.             document.body.appendChild(infoPopupElement);
  598.             const rect = iconElement.getBoundingClientRect();
  599.             infoPopupElement.style.top = `${rect.bottom + window.scrollY + 5}px`;
  600.             infoPopupElement.style.left = `${rect.left + window.scrollX}px`;
  601.             setTimeout(() => infoPopupElement.classList.add('active'), 10);
  602.             document.addEventListener('click', handleClickOutsideInfoPopup, true);
  603.         } catch (e) {
  604.             console.error('Error showing info popup:', e);
  605.         }
  606.     }
  607.  
  608.     function handleClickOutsideInfoPopup(event) {
  609.         if (infoPopupElement && !infoPopupElement.contains(event.target) && !event.target.classList.contains('taqtaq-info-icon')) {
  610.             hideInfoPopup();
  611.         }
  612.     }
  613.  
  614.     function hideInfoPopup() {
  615.         if (infoPopupElement) {
  616.             infoPopupElement.remove();
  617.             infoPopupElement = null;
  618.             document.removeEventListener('click', handleClickOutsideInfoPopup, true);
  619.         }
  620.     }
  621.  
  622.     function makeDraggable(element, handle) {
  623.         let pos1 = 0, pos2 = 0, pos3 = 0, pos4 = 0;
  624.         handle.onmousedown = (e) => {
  625.             e.preventDefault();
  626.             pos3 = e.clientX;
  627.             pos4 = e.clientY;
  628.             element.style.transition = 'none'; // Disable transition during drag
  629.             document.onmousemove = throttle(elementDrag, 10); // Faster throttle (100fps)
  630.             document.onmouseup = () => {
  631.                 document.onmousemove = null;
  632.                 document.onmouseup = null;
  633.                 element.style.transition = 'all 0.3s ease-out'; // Re-enable transition
  634.             };
  635.         };
  636.         function elementDrag(e) {
  637.             pos1 = pos3 - e.clientX;
  638.             pos2 = pos4 - e.clientY;
  639.             pos3 = e.clientX;
  640.             pos4 = e.clientY;
  641.             requestAnimationFrame(() => {
  642.                 element.style.top = `${Math.max(0, Math.min(window.innerHeight - element.offsetHeight, element.offsetTop - pos2))}px`;
  643.                 element.style.left = `${Math.max(0, Math.min(window.innerWidth - element.offsetWidth, element.offsetLeft - pos1))}px`;
  644.             });
  645.         }
  646.     }
  647.  
  648.     function throttle(func, limit) {
  649.         let inThrottle;
  650.         return function(...args) {
  651.             if (!inThrottle) {
  652.                 func.apply(this, args);
  653.                 inThrottle = true;
  654.                 setTimeout(() => inThrottle = false, limit);
  655.             }
  656.         };
  657.     }
  658.  
  659.     async function handleVoiceInput(textField) {
  660.         if (!('webkitSpeechRecognition' in window)) {
  661.             alert('Voice input not supported in this browser.');
  662.             return;
  663.         }
  664.         try {
  665.             const recognition = new window.webkitSpeechRecognition();
  666.             recognition.continuous = true;
  667.             recognition.interimResults = true;
  668.             recognition.onresult = (event) => {
  669.                 let transcript = '';
  670.                 for (let i = event.resultIndex; i < event.results.length; i++) {
  671.                     transcript += event.results[i][0].transcript;
  672.                 }
  673.                 textField.value = transcript;
  674.             };
  675.             recognition.onerror = (e) => console.error('Voice recognition error:', e);
  676.             recognition.start();
  677.             setTimeout(() => recognition.stop(), 5000);
  678.         } catch (e) {
  679.             console.error('Error with voice input:', e);
  680.         }
  681.     }
  682.  
  683.     async function startTypingProcess(textField) {
  684.         const inputElement = findInputElement();
  685.         if (!inputElement) {
  686.             alert('Could not find input area. Place cursor in Doc/Slide.');
  687.             return;
  688.         }
  689.         const text = textField.value.trim();
  690.         if (!text) {
  691.             alert('Please enter text to type.');
  692.             return;
  693.         }
  694.         typingInProgress = true;
  695.         cancelTyping = false;
  696.         stats = { time: 0, errors: 0, chars: 0, aiCalls: 0 };
  697.         overlayElement.style.display = 'none';
  698.         const stopButton = document.getElementById('stop-button');
  699.         if (stopButton) stopButton.style.display = 'inline-block';
  700.         try {
  701.             const start = Date.now();
  702.             await typeStringWithLogic(inputElement, text);
  703.             stats.time = Date.now() - start;
  704.             updateStats();
  705.             if (settings.autoSave) inputHistory.push(text);
  706.         } catch (e) {
  707.             console.error('Typing process error:', e);
  708.         } finally {
  709.             typingInProgress = false;
  710.             if (stopButton) {
  711.                 stopButton.style.display = 'none';
  712.                 stopButton.textContent = 'Stop';
  713.             }
  714.         }
  715.     }
  716.  
  717.     function findInputElement() {
  718.         try {
  719.             const iframe = document.querySelector('.docs-texteventtarget-iframe');
  720.             if (iframe && iframe.contentDocument) {
  721.                 return iframe.contentDocument.activeElement || iframe.contentDocument.body;
  722.             }
  723.             return document.activeElement || document.body;
  724.         } catch (e) {
  725.             console.error('Error finding input element:', e);
  726.             return null;
  727.         }
  728.     }
  729.  
  730.     async function typeStringWithLogic(inputElement, string) {
  731.         const personaSettings = PERSONAS[settings.persona];
  732.         const emotionSettings = EMOTIONS[settings.emotion];
  733.         let i = 0;
  734.         while (i < string.length) {
  735.             if (cancelTyping) break;
  736.             if (/\w/.test(string[i])) {
  737.                 const wordStart = i;
  738.                 while (i < string.length && /\w/.test(string[i])) i++;
  739.                 const word = string.slice(wordStart, i);
  740.                 const typoRate = settings.typoRatePercent * (personaSettings.typoRateMultiplier || 1) * (emotionSettings.typoRateMultiplier || 1);
  741.                 const hasTypo = settings.enableTypos && Math.random() < (typoRate / 100);
  742.                 await typeWord(inputElement, string, wordStart, i, hasTypo ? Math.floor(Math.random() * (word.length - 1)) : -1);
  743.             } else {
  744.                 const delayMs = calculateDelay(string, i);
  745.                 await simulateKey(inputElement, string[i], delayMs);
  746.                 if (/[.!?]/.test(string[i]) && settings.enableSentencePauses && Math.random() < settings.sentencePauseProbability) {
  747.                     await delay(settings.sentencePauseDurationMinutes * 60 * 1000);
  748.                 }
  749.                 i++;
  750.                 stats.chars++;
  751.             }
  752.             if (settings.enableAI && Math.random() < settings.aiFillerFreq * (personaSettings.pauseFreqMultiplier || 1) * (emotionSettings.pauseFreqMultiplier || 1)) {
  753.                 const filler = await generateAIText(`Short ${personaSettings.aiPrompt} phrase`, 10);
  754.                 await delay(500);
  755.                 await typeText(inputElement, filler + ' ', 100);
  756.                 await delay(500);
  757.                 for (let j = 0; j < filler.length + 1; j++) await simulateKey(inputElement, '\b', 50);
  758.                 stats.aiCalls++;
  759.             }
  760.             if (settings.gamifiedStats && Math.random() < 0.01) {
  761.                 const scoreText = ` [Score: ${stats.chars}] `;
  762.                 await typeText(inputElement, scoreText, 50);
  763.                 await delay(1000);
  764.                 for (let j = 0; j < scoreText.length; j++) await simulateKey(inputElement, '\b', 50);
  765.             }
  766.             if (Math.random() < settings.modeSwitchProbability) isFastMode = !isFastMode;
  767.         }
  768.     }
  769.  
  770.     async function typeWord(inputElement, string, start, end, typoPosition) {
  771.         const personaSettings = PERSONAS[settings.persona];
  772.         for (let j = start; j < end; j++) {
  773.             if (cancelTyping) return;
  774.             let delayMs = calculateDelay(string, j);
  775.             if (j === typoPosition || (settings.enableAI && settings.aiTypingEnhance && Math.random() < 0.1)) {
  776.                 if (settings.aiTypingEnhance && settings.enableAI) {
  777.                     await aiSimulateTypo(inputElement, string[j], personaSettings.aiTypoStyle);
  778.                 } else {
  779.                     const wrongChar = getNearbyKey(string[j]);
  780.                     await simulateKey(inputElement, wrongChar, settings.typoCharDelayMs);
  781.                     const extraTypos = Math.floor(Math.random() * settings.maxTypoLength);
  782.                     for (let k = 0; k < extraTypos; k++) {
  783.                         await simulateKey(inputElement, getNearbyKey(string[j]), settings.typoCharDelayMs);
  784.                     }
  785.                     await delay(settings.useAdvancedAlgorithm ?
  786.                         Math.random() * (settings.advTypoRecognitionMaxMs - settings.advTypoRecognitionMinMs) + settings.advTypoRecognitionMinMs :
  787.                         settings.typoPreBackspaceDelayMs);
  788.                     for (let k = 0; k < extraTypos + 1; k++) {
  789.                         await simulateKey(inputElement, '\b', settings.useAdvancedAlgorithm ? settings.advBackspaceDelayMs : settings.backspaceDelayMs);
  790.                     }
  791.                 }
  792.                 stats.errors++;
  793.             }
  794.             await simulateKey(inputElement, string[j], delayMs);
  795.             stats.chars++;
  796.         }
  797.     }
  798.  
  799.     async function aiSimulateTypo(inputElement, correctChar, typoStyle) {
  800.         switch (typoStyle) {
  801.             case 'random pauses':
  802.                 await delay(Math.random() * 300 + 200);
  803.                 await simulateKey(inputElement, correctChar, 0);
  804.                 break;
  805.             case 'frequent backspaces':
  806.                 await simulateKey(inputElement, getNearbyKey(correctChar), settings.typoCharDelayMs);
  807.                 await delay(200);
  808.                 await simulateKey(inputElement, '\b', settings.backspaceDelayMs);
  809.                 await simulateKey(inputElement, correctChar, 0);
  810.                 break;
  811.             case 'missed letters':
  812.                 if (Math.random() < 0.5) await simulateKey(inputElement, correctChar, 0);
  813.                 else {
  814.                     await delay(150);
  815.                     await simulateKey(inputElement, correctChar, 0);
  816.                 }
  817.                 break;
  818.             case 'extra letters':
  819.                 await simulateKey(inputElement, correctChar, settings.typoCharDelayMs);
  820.                 const extra = Math.floor(Math.random() * 2);
  821.                 for (let i = 0; i < extra; i++) {
  822.                     await simulateKey(inputElement, getNearbyKey(correctChar), settings.typoCharDelayMs);
  823.                 }
  824.                 await delay(300);
  825.                 for (let i = 0; i < extra; i++) {
  826.                     await simulateKey(inputElement, '\b', settings.backspaceDelayMs);
  827.                 }
  828.                 break;
  829.             case 'subtle hesitations':
  830.                 await delay(Math.random() * 150 + 100);
  831.                 await simulateKey(inputElement, correctChar, 0);
  832.                 if (Math.random() < 0.3) {
  833.                     await simulateKey(inputElement, '\b', settings.backspaceDelayMs);
  834.                     await delay(100);
  835.                     await simulateKey(inputElement, correctChar, 0);
  836.                 }
  837.                 break;
  838.             default:
  839.                 await simulateKey(inputElement, getNearbyKey(correctChar), settings.typoCharDelayMs);
  840.                 await delay(200);
  841.                 await simulateKey(inputElement, '\b', settings.backspaceDelayMs);
  842.                 await simulateKey(inputElement, correctChar, 0);
  843.         }
  844.         stats.aiCalls++;
  845.     }
  846.  
  847.     function calculateDelay(string, i) {
  848.         let baseDelay = Math.random() * (settings.upperBound - settings.lowerBound) + settings.lowerBound;
  849.         if (settings.useAdvancedAlgorithm) {
  850.             const prevChar = i > 0 ? string[i - 1] : null;
  851.             const nextChar = i < string.length - 1 ? string[i + 1] : null;
  852.             if (prevChar === ' ') baseDelay *= Math.random() * (settings.advSpaceMax - settings.advSpaceMin) + settings.advSpaceMin;
  853.             else if (/[.,!?;:]/.test(prevChar)) baseDelay *= settings.advPunctuationMultiplier;
  854.             else if (/\w/.test(string[i]) && (nextChar === ' ' || !nextChar)) baseDelay *= Math.random() * (settings.advWordEndMax - settings.advWordEndMin) + settings.advWordEndMin;
  855.             if (Math.random() < settings.advRandomPauseChance) baseDelay += Math.random() * (settings.advRandomPauseMaxMs - settings.advRandomPauseMinMs) + settings.advRandomPauseMinMs;
  856.         }
  857.         return baseDelay * (isFastMode ? settings.fastModeFactor : settings.slowModeFactor) * settings.speedMultiplier * (EMOTIONS[settings.emotion].speedMod || 1);
  858.     }
  859.  
  860.     async function simulateKey(inputElement, charOrCode, keyDelay) {
  861.         if (cancelTyping) return;
  862.         try {
  863.             const eventProps = { bubbles: true, cancelable: true };
  864.             let eventType, keyEventProps;
  865.             if (charOrCode === '\n') {
  866.                 eventType = 'keydown';
  867.                 keyEventProps = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13 };
  868.             } else if (charOrCode === '\b') {
  869.                 eventType = 'keydown';
  870.                 keyEventProps = { key: 'Backspace', code: 'Backspace', keyCode: 8, which: 8 };
  871.             } else {
  872.                 eventType = 'keypress';
  873.                 keyEventProps = { key: charOrCode, charCode: charOrCode.charCodeAt(0), keyCode: charOrCode.charCodeAt(0), which: charOrCode.charCodeAt(0) };
  874.             }
  875.             Object.assign(eventProps, keyEventProps);
  876.             const event = new KeyboardEvent(eventType, eventProps);
  877.             inputElement.dispatchEvent(event);
  878.             if (settings.enableSound) playTypingSound(SOUNDSCAPES[settings.soundscape] || TYPING_SOUND_URL);
  879.             if (settings.enableHaptics) window.navigator.vibrate?.(10);
  880.             await delay(keyDelay);
  881.         } catch (e) {
  882.             console.error('Error simulating key:', e);
  883.         }
  884.     }
  885.  
  886.     async function typeText(inputElement, text, delayMs) {
  887.         for (let char of text) {
  888.             await simulateKey(inputElement, char, delayMs);
  889.         }
  890.     }
  891.  
  892.     async function generateAIText(prompt, maxTokens) {
  893.         if (!API_KEY || API_KEY === DEFAULT_API_KEY) {
  894.             await delay(500);
  895.             return 'uhh...';
  896.         }
  897.         return new Promise((resolve) => {
  898.             GM_xmlhttpRequest({
  899.                 method: 'POST',
  900.                 url: 'https://api.openai.com/v1/completions',
  901.                 headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${API_KEY}` },
  902.                 data: JSON.stringify({ model: 'text-davinci-003', prompt, max_tokens: maxTokens }),
  903.                 onload: (response) => resolve(JSON.parse(response.responseText).choices[0].text.trim()),
  904.                 onerror: () => {
  905.                     delay(500).then(() => resolve('uhh...'));
  906.                 }
  907.             });
  908.         });
  909.     }
  910.  
  911.     function playTypingSound(url) {
  912.         try {
  913.             new Audio(url).play().catch(e => console.warn('Sound playback failed:', e));
  914.         } catch (e) {
  915.             console.error('Error playing sound:', e);
  916.         }
  917.     }
  918.  
  919.     function updateStats() {
  920.         const speed = stats.time > 0 ? (stats.chars / (stats.time / 1000)).toFixed(2) : 0;
  921.         const statsLabel = document.querySelector('.taqtaq-stats');
  922.         if (statsLabel) statsLabel.textContent = `Speed: ${speed} chars/sec | Errors: ${stats.errors} | AI Calls: ${stats.aiCalls}`;
  923.     }
  924.  
  925.     function getNearbyKey(char) {
  926.         const keyboard = {
  927.             'q': 'wa', 'w': 'qase', 'e': 'wsdr', 'r': 'edft', 't': 'rfgy', 'y': 'tghu', 'u': 'yhji', 'i': 'ujko', 'o': 'iklp', 'p': 'ol',
  928.             'a': 'qsxz', 's': 'awdcz', 'd': 'serfx', 'f': 'drtgv', 'g': 'ftyhb', 'h': 'gyujn', 'j': 'huikm', 'k': 'jiol', 'l': 'kop'
  929.         };
  930.         const lowerChar = char.toLowerCase();
  931.         const adjacent = keyboard[lowerChar] || char;
  932.         return adjacent[Math.floor(Math.random() * adjacent.length)] || char;
  933.     }
  934.  
  935.     function delay(ms) {
  936.         return new Promise(resolve => setTimeout(() => resolve(!cancelTyping), ms));
  937.     }
  938.  
  939.     const initInterval = setInterval(() => {
  940.         if (document.getElementById('docs-extensions-menu') && document.querySelector('.docs-texteventtarget-iframe')) {
  941.             console.log('Extensions menu and iframe found, initializing...');
  942.             clearInterval(initInterval);
  943.             initializeScript();
  944.         } else {
  945.             console.log('Waiting for Extensions menu or iframe...');
  946.         }
  947.     }, 500);
  948.  
  949.     setTimeout(() => {
  950.         if (!document.getElementById('typepulsex-button')) {
  951.             console.error('Initialization timeout. Script may not work on this page. Check if Extensions menu exists.');
  952.             clearInterval(initInterval);
  953.         }
  954.     }, 10000);
  955. })();

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址