An auto-typing script with customizable speed and accuracy for Nitro Type.
// ==UserScript==
// @name Auto Typer for Nitro Type (NEW 2025)
// @namespace http://tampermonkey.net/
// @version 1.0.0
// @description An auto-typing script with customizable speed and accuracy for Nitro Type.
// @author Anon2004
// @match https://www.nitrotype.com/race
// @match https://www.nitrotype.com/race/*
// @icon https://cdn2.steamgriddb.com/icon/2b16a44bb65751bb0ebe5d8b42644bc4/32/512x512.png
// @license MIT
// @grant none
// ==/UserScript==
/*
===================================================================================
🛠️ SETUP INSTRUCTIONS – PLEASE READ CAREFULLY
===================================================================================
To customize the WPM (Words Per Minute) and Accuracy ranges for typing sessions:
---------------------------------------------------
STEP 1: Update the configuration values
---------------------------------------------------
⬇️ DO NOT edit anything in this comment block. ⬇️
Scroll down and find the following lines in the code:
AppConfig.get wpmValues
AppConfig.get accuracies
You’ll see something like:
const MIN_WPM = 100;
const MAX_WPM = 125;
const MIN_ACC = 95;
const MAX_ACC = 99;
🎯 Change these `MIN_` and `MAX_` values to set your preferred WPM and accuracy ranges.
💾 After making changes, save the file:
File > Save (or press Ctrl+S / Cmd+S)
⚠️ Stick to updating the min/max values only — leave `SESSIONS` untouched.
---------------------------------------------------
STEP 2: Clear the session cache
---------------------------------------------------
WPM and accuracy values are cached in `localStorage` when sessions start.
To apply your new settings, you **must** reset the cache.
⚠️ Run the following code from the browser console
**on the Nitro Type race page**, not elsewhere.
How to do it:
1. Go to nitrotype.com/race.
2. Open Developer Tools:
- Press F12 or Ctrl+Shift+I (Windows/Linux)
- Or Cmd+Option+I (Mac)
3. Go to the “Console” tab.
4. Paste and run this code:
(() => {
localStorage.setItem('typingWpmSessionCount', '1');
localStorage.setItem('typingAccuracySessionCount', '1');
localStorage.setItem('typingAccuracyBufferCount', '1');
localStorage.removeItem('dynamicWpmValues');
localStorage.removeItem('dynamicAccuracies');
window.location.reload();
})();
✅ This clears cached values and resets session counters.
Your updated min/max settings will take effect after the page reloads.
---------------------------------------------------
💬 Additional Notes
---------------------------------------------------
✔️ All changes are local to your browser. Nitro Type won’t detect them —
unless you set unusually high or suspicious values (e.g. WPM 300+, or 100% accuracy every time).
👀 Keep the **Console tab open** while using this setup — important debug info (like current WPM, accuracy, and mode-switch instructions) is printed there.
🎮 Mode Descriptions:
Auto Mode: Automatically simulates and injects keystrokes at the configured typing speed without user intervention.
Manual Mode: Waits for a user trigger before injecting each keystroke, giving you step-by-step control over the typing.
Normal Mode: Disables all automation hacks and behaves like a standard, unmodified typing experience.
===================================================================================
*/
// ===== CORE CONSTANTS AND CONFIGURATION =====
/**
* Application modes with state preservation
*/
const AppModes = {
AUTO: 'auto',
MANUAL: 'manual',
NORMAL: 'normal',
STORAGE_KEY: 'typingAppMode'
};
/**
* Application-wide constants for typing parameters, events, storage keys, and behavior factors
*/
const Constants = {
TYPING: { CHARS_PER_WORD: 5, MS_PER_MINUTE: 60 * 1000 },
EVENTS: {
MODE_CHANGE: 'modeChange',
METRICS_UPDATED: 'metricsUpdated',
SESSION_COMPLETED: 'sessionCompleted',
COUNTERS_INCREMENTED: 'countersIncremented',
MANUAL_SESSION_COMPLETED: 'manualSessionCompleted',
SESSION_COMPLETED_REFRESH: 'sessionCompletedRefresh'
},
STORAGE: {
WPM_SESSION_COUNT: 'typingWpmSessionCount',
ACCURACY_SESSION_COUNT: 'typingAccuracySessionCount',
ACCURACY_BUFFER_COUNT: 'typingAccuracyBufferCount',
DYNAMIC_WPM_VALUES: 'dynamicWpmValues',
DYNAMIC_ACCURACIES: 'dynamicAccuracies'
},
BEHAVIOR: {
MIN_DELAY_FACTOR: 0.4,
MAX_DELAY_FACTOR: 1.8,
WORD_BOUNDARY_MIN: 1.05,
WORD_BOUNDARY_MAX: 0.1,
COMMON_SEQ_MIN: 0.85,
COMMON_SEQ_MAX: 0.05
}
};
/**
* Centralized application configuration with target WPM, accuracy values, and typing parameters
*/
const AppConfig = {
// Helper to generate and cache arrays
_generateDynamicArray(storageKey, count, min, max) {
let arr = JSON.parse(localStorage.getItem(storageKey) || 'null');
if (!Array.isArray(arr) || arr.length !== count) {
arr = Array.from(
{ length: count },
() => Math.floor(Math.random() * (max - min + 1)) + min
);
localStorage.setItem(storageKey, JSON.stringify(arr));
}
return arr;
},
// Target WPM values for each session, generated once and saved to localStorage
get wpmValues() {
const SESSIONS = 10;
const MIN_WPM = 100;
const MAX_WPM = 125;
return this._generateDynamicArray(
Constants.STORAGE.DYNAMIC_WPM_VALUES,
SESSIONS,
MIN_WPM,
MAX_WPM
);
},
// Target accuracy values for each session, generated once and saved to localStorage
get accuracies() {
const SESSIONS = 10;
const MIN_ACC = 95;
const MAX_ACC = 99;
return this._generateDynamicArray(
Constants.STORAGE.DYNAMIC_ACCURACIES,
SESSIONS,
MIN_ACC,
MAX_ACC
);
},
// Accuracy buffer values that cycle
accuracyBuffers: [0.7, 0.7, 0.7, 0.7, 0.7, 0, 0, 0, 0, 0],
// Common sequences typed faster by humans
commonSequences: ['th', 'he', 'in', 'er', 'an', 'en', 'ing', 'the', 'and'],
// Word boundary characters
wordBoundaries: [' ', '.', ',', ';', ':'],
// Parameters controlling typing behavior
typingParams: {
allowedDeviation: 2,
correctionStrength: 0.8,
humanVariationStrength: 0.25,
microPauseChance: 0.06,
burstChance: 0.12,
hesitationChance: 0.05,
maxMicroPause: 200,
feedbackInterval: 800,
wpmSmoothingFactor: 0.6,
overcompensationFactor: 1.5,
speedBoost: 0.85,
adaptationRate: 0.2,
earlyBoostFactor: 0.7
}
};
// ===== CORE UTILITY CLASSES =====
/**
* Simple event system to enable communication between components
*/
class EventBus {
constructor() {
this.events = {};
}
// Register an event listener
on(event, listener) {
if (!this.events[event]) this.events[event] = [];
this.events[event].push(listener);
return this;
}
// Emit an event to all listeners
emit(event, ...args) {
if (!this.events[event]) return false;
this.events[event].forEach(listener => listener(...args));
return true;
}
// Remove an event listener
off(event, listener) {
if (!this.events[event]) return this;
this.events[event] = this.events[event].filter(l => l !== listener);
return this;
}
}
/**
* Centralized logging with consistent message formatting
*/
class Logger {
// Shared logging method to standardize format
static _log(prefix, message, context = '') {
const contextPrefix = context ? `[${context}] ` : '';
console.log(`${contextPrefix}${prefix}${message}`);
}
// Standard logging methods with different prefixes
static log(message, context = '') {
this._log('', message, context);
}
static info(message, context = '') {
this._log('', message, context);
}
static warn(message, context = '') {
this._log('⚠️ ', message, context);
}
static error(message, context = '') {
console.error(`${context ? `[${context}] ` : ''}🔴 ${message}`);
}
static success(message, context = '') {
this._log('✅ ', message, context);
}
// Helper for logging metrics in consistent format
static logMetric(name, value, target = null, context = '') {
this.info(`${name}: ${Utils.formatNumber(value)}${target !== null ? ` (Target: ${target})` : ''}`, context);
}
// Helper for logging session info in consistent format
static logSessionInfo(config, context = '') {
this.info(`Session info: WPM #${config.wpmSessionCount}/${AppConfig.wpmValues.length} (${config.targetWPM} WPM) | Accuracy #${config.accuracySessionCount}/${AppConfig.accuracies.length} (${config.targetAccuracy}%)`, context);
}
}
/**
* Handles localStorage operations to persist session data
*/
class StorageService {
// Get value from localStorage with default fallback
static get(key, defaultValue) {
return parseInt(localStorage.getItem(key) || defaultValue.toString());
}
// Set value in localStorage
static set(key, value) {
localStorage.setItem(key, value);
}
/**
* Increments a counter in localStorage, cycling back to 1 when reaching max
*/
static increment(key, maxValue, defaultValue = 0) {
let count = this.get(key, defaultValue) + 1;
if (count > maxValue) {
Logger.info(`Completed full ${key} cycle. Resetting counter (was at ${count})`);
count = 1;
}
this.set(key, count);
return count;
}
}
/**
* General utilities for common operations
*/
class Utils {
// Create a promise that resolves after specific time
static delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
// Analyze content to find the longest word and its position
static getLongestWord(content) {
const words = content.split(/\s+/);
let longest = { word: "", index: 0 };
for (let i = 0; i < words.length; i++) {
if (words[i].length > longest.word.length) {
longest.word = words[i];
longest.index = content.indexOf(longest.word);
}
}
return longest;
}
// Format number with specified decimal places
static formatNumber(num, decimals = 2) {
if (num === undefined || num === null) return "0.00";
return num.toFixed(decimals);
}
// Apply random variation within a range
static applyRandomVariation(base, minFactor, maxVariation) {
return base * (minFactor + Math.random() * maxVariation);
}
// Check if string starts with any pattern from array
static startsWithAny(str, patterns) {
return patterns.some(pattern => str.startsWith(pattern));
}
// Check if character is in array
static isInArray(char, array) {
return array.includes(char);
}
// Keep value within bounds
static boundValue(value, min, max) {
return Math.max(min, Math.min(max, value));
}
// Retry operation until success
static async retryUntilSuccess(operation, interval = 500) {
if (operation()) return true;
return new Promise(resolve => {
const checkInterval = setInterval(() => {
if (operation()) {
clearInterval(checkInterval);
resolve(true);
}
}, interval);
});
}
// Apply a pattern if condition is met, otherwise return null
static applyPatternIf(condition, factorFn, baseFactor) {
if (condition) return factorFn(baseFactor);
return null;
}
}
// ===== CONFIGURATION =====
/**
* Manages configuration and session state
*/
class ConfigService {
constructor(eventBus) {
this.eventBus = eventBus;
this.loadConfig();
}
// Load configuration values from storage
loadConfig() {
const savedMode = localStorage.getItem(AppModes.STORAGE_KEY) || AppModes.AUTO;
this._typingMode = savedMode;
this._accuracySessionCount = StorageService.get(Constants.STORAGE.ACCURACY_SESSION_COUNT, 1);
this._wpmSessionCount = StorageService.get(Constants.STORAGE.WPM_SESSION_COUNT, 1);
this._accuracyBufferCount = StorageService.get(Constants.STORAGE.ACCURACY_BUFFER_COUNT, 1);
this.typingParams = AppConfig.typingParams;
}
// Getters and setters for the typing mode
get typingMode() {
return this._typingMode;
}
set typingMode(value) {
this._typingMode = value;
localStorage.setItem(AppModes.STORAGE_KEY, value);
this.eventBus.emit(Constants.EVENTS.MODE_CHANGE, value);
}
// Helper methods to check specific modes
get isAutoTypingMode() {
return this._typingMode === AppModes.AUTO;
}
get isManualTypingMode() {
return this._typingMode === AppModes.MANUAL;
}
get isNormalTypingMode() {
return this._typingMode === AppModes.NORMAL;
}
// Return the target WPM for current session
get targetWPM() {
return AppConfig.wpmValues[this._wpmSessionCount - 1];
}
// Return the target accuracy for current session
get targetAccuracy() {
return AppConfig.accuracies[this._accuracySessionCount - 1];
}
// Return the target accuracy buffer for current session
get targetAccuracyBuffer() {
return AppConfig.accuracyBuffers[this._accuracyBufferCount - 1];
}
get wpmSessionCount() {
return this._wpmSessionCount;
}
get accuracySessionCount() {
return this._accuracySessionCount;
}
get accuracyBufferCount() {
return this._accuracyBufferCount;
}
// Increment session counters and emit event
incrementCounters() {
// Skip incrementing counters in normal mode
if (this.isNormalTypingMode) {
return {
wpmSession: this._wpmSessionCount,
accuracySession: this._accuracySessionCount,
accuracyBufferSession: this._accuracyBufferCount
};
}
// Increment all counters with a helper method
this._wpmSessionCount = this._incrementCounter(
Constants.STORAGE.WPM_SESSION_COUNT,
AppConfig.wpmValues.length
);
this._accuracySessionCount = this._incrementCounter(
Constants.STORAGE.ACCURACY_SESSION_COUNT,
AppConfig.accuracies.length
);
this._accuracyBufferCount = this._incrementCounter(
Constants.STORAGE.ACCURACY_BUFFER_COUNT,
AppConfig.accuracyBuffers.length
);
// If we've wrapped back to the first WPM session, clear cached arrays so they're regenerated
if (this._wpmSessionCount === 1) {
localStorage.removeItem(Constants.STORAGE.DYNAMIC_WPM_VALUES);
localStorage.removeItem(Constants.STORAGE.DYNAMIC_ACCURACIES);
}
const counters = {
wpmSession: this._wpmSessionCount,
accuracySession: this._accuracySessionCount,
accuracyBufferSession: this._accuracyBufferCount
};
this.eventBus.emit(Constants.EVENTS.COUNTERS_INCREMENTED, counters);
return counters;
}
// Helper method to increment a counter
_incrementCounter(key, maxValue) {
return StorageService.increment(key, maxValue);
}
}
// ===== DOM INTERFACE =====
/**
* Handles DOM interactions and provides access to typing app node
*/
class DOMInterface {
// Extract typing app node from the DOM
getTypingAppNode() {
try {
return Object.values(document.querySelector("div.dash-copyContainer"))[1].children._owner.stateNode;
} catch (error) {
Logger.error(`Could not access typing app node: ${error}`, 'DOMInterface');
return null;
}
}
}
// ===== METRICS TRACKING =====
/**
* Tracks and calculates typing metrics and performance
*/
class MetricsService {
constructor(configService, eventBus) {
this.config = configService;
this.eventBus = eventBus;
this.reset();
}
// Reset all metrics to initial values
reset() {
this.totalKeystrokes = 0;
this.correctKeystrokes = 0;
this.typingStartTime = null;
this.charactersTyped = 0;
this.lastFeedbackTime = 0;
this.currentWPM = 0;
this.smoothedWPM = 0;
// Calculate target CPM and base delay
this.targetCPM = this.config.targetWPM * Constants.TYPING.CHARS_PER_WORD;
this.baseDelayMs = (Constants.TYPING.MS_PER_MINUTE) / this.targetCPM * this.config.typingParams.speedBoost;
this.currentDelayMs = this.baseDelayMs;
// Tracking variables
this.typingPattern = [];
this.lastKeystrokeTime = 0;
this.cumulativeDeviation = 0;
this.wpmHistory = [];
this.adjustmentHistory = [];
this.delayOffset = 0;
// Startup phase tracking
this.startupPhaseDone = false;
this.startupCounter = 0;
this.initialBoostApplied = false;
this.sessionCompleted = false;
}
// Calculate current typing accuracy
get currentAccuracy() {
return this.totalKeystrokes > 0 ? (this.correctKeystrokes / this.totalKeystrokes) * 100 : 100;
}
// Update keystroke stats (correct or incorrect)
updateKeystrokeStats(isCorrect) {
this.totalKeystrokes++;
if (isCorrect) this.correctKeystrokes++;
this.emitMetricsUpdate();
}
// Track a correct keystroke
trackCorrectKeystroke() {
this.updateKeystrokeStats(true);
}
// Track an incorrect keystroke
trackIncorrectKeystroke() {
this.updateKeystrokeStats(false);
}
// Update WPM calculation based on typing progress
updateWPM(newChars) {
// Initialize start time on first update
if (this.typingStartTime === null) {
this.typingStartTime = Date.now();
this.lastKeystrokeTime = Date.now();
return 0;
}
this.charactersTyped += newChars;
const currentTime = Date.now();
const elapsedMinutes = (currentTime - this.typingStartTime) / Constants.TYPING.MS_PER_MINUTE;
// Calculate WPM if enough time has passed
if (elapsedMinutes > 0) {
// Calculate instant WPM and apply smoothing
const instantWPM = (this.charactersTyped / Constants.TYPING.CHARS_PER_WORD) / elapsedMinutes;
this.smoothedWPM = this.smoothedWPM === 0
? instantWPM
: this.smoothedWPM * this.config.typingParams.wpmSmoothingFactor +
instantWPM * (1 - this.config.typingParams.wpmSmoothingFactor);
this.currentWPM = this.smoothedWPM;
this._updateWpmHistory(currentTime);
return this.currentWPM;
}
return 0;
}
// Update WPM history and provide feedback
_updateWpmHistory(currentTime) {
// Maintain a rolling window of recent WPM values
if (this.wpmHistory.length > 10) this.wpmHistory.shift();
this.wpmHistory.push(this.currentWPM);
// Provide periodic feedback on typing speed
if (currentTime - this.lastFeedbackTime > this.config.typingParams.feedbackInterval) {
Logger.logMetric('Current typing speed', this.currentWPM, this.config.targetWPM, 'WPM');
this.lastFeedbackTime = currentTime;
this._handleSpeedDeviation();
}
this._handleStartupPhase();
}
// Handle deviations from target WPM
_handleSpeedDeviation() {
const deviation = this.currentWPM - this.config.targetWPM;
const deviationPercent = Utils.formatNumber(Math.abs(deviation) / this.config.targetWPM * 100, 1);
if (Math.abs(deviation) > this.config.typingParams.allowedDeviation) {
if (deviation < 0) {
Logger.warn(`TOO SLOW: ${Utils.formatNumber(Math.abs(deviation), 1)} WPM below target (${deviationPercent}%) - Increasing typing speed...`, 'WPM');
} else {
Logger.warn(`TOO FAST: ${Utils.formatNumber(deviation, 1)} WPM above target (${deviationPercent}%) - Reducing typing speed...`, 'WPM');
}
this._adjustForConsistentDeviation(deviation);
}
}
// Make adjustments for consistent deviations
_adjustForConsistentDeviation(deviation) {
if (this.wpmHistory.length >= 5) {
const recentAvg = this.wpmHistory.slice(-5).reduce((sum, wpm) => sum + wpm, 0) / 5;
const avgDeviation = recentAvg - this.config.targetWPM;
if (Math.abs(avgDeviation) > this.config.typingParams.allowedDeviation) {
const adjustmentFactor = -avgDeviation * 0.015;
this.delayOffset += adjustmentFactor;
Logger.info(`🔄 Making permanent base delay adjustment: ${Utils.formatNumber(adjustmentFactor, 3)}ms (cumulative: ${Utils.formatNumber(this.delayOffset, 3)}ms)`, 'WPM');
}
}
}
// Handle special adjustments during startup phase
_handleStartupPhase() {
if (!this.startupPhaseDone) {
this.startupCounter++;
// Apply initial boost if typing too slow
if (this.startupCounter === 10 && !this.initialBoostApplied) {
if (this.currentWPM < this.config.targetWPM * 0.9) {
const boostFactor = 0.7; // 30% faster typing
this.baseDelayMs *= boostFactor;
this.currentDelayMs *= boostFactor;
this.initialBoostApplied = true;
Logger.info(`🚀 Initial speed boost applied! Base delay reduced to ${Utils.formatNumber(this.baseDelayMs)}ms`, 'WPM');
}
}
// End startup phase after sufficient keystrokes
if (this.startupCounter >= 30) {
this.startupPhaseDone = true;
Logger.info("Startup phase complete, switching to normal control mode", 'WPM');
}
}
}
// Emit metrics updates and log feedback
emitMetricsUpdate() {
// Log accuracy periodically
if (this.totalKeystrokes % 20 === 0) {
this._logAccuracyFeedback();
}
this.eventBus.emit(Constants.EVENTS.METRICS_UPDATED, {
accuracy: this.currentAccuracy,
wpm: this.currentWPM,
keystrokes: this.totalKeystrokes,
correctKeystrokes: this.correctKeystrokes,
accuracyBuffer: this.config.targetAccuracyBuffer
});
}
// Log accuracy feedback in consistent format
_logAccuracyFeedback() {
Logger.logMetric('Current accuracy', this.currentAccuracy, this.config.targetAccuracy, 'Accuracy');
Logger.info(`(${this.correctKeystrokes}/${this.totalKeystrokes})`, 'Accuracy');
}
// Mark session as complete and emit event
markSessionComplete() {
if (this.sessionCompleted) return;
this.sessionCompleted = true;
this.eventBus.emit(Constants.EVENTS.SESSION_COMPLETED, {
finalWPM: this.currentWPM || 0,
finalAccuracy: this.currentAccuracy || 0
});
}
// Log history of WPM adjustments
logAdjustmentHistory() {
Logger.info("WPM and delay adjustment history:", 'Metrics');
this.adjustmentHistory.forEach((item, i) => {
Logger.info(`${i}: WPM=${Utils.formatNumber(item.wpm, 1)}, Target=${item.targetWpm}, Delay=${Utils.formatNumber(item.adjustedDelay, 1)}ms`, 'Metrics');
});
}
}
// ===== TIMING CONTROLLER =====
/**
* Controls timing between keystrokes to achieve target WPM
*/
class TimingController {
constructor(metricsService, configService) {
this.metrics = metricsService;
this.config = configService;
}
/**
* Calculate delay for next keystroke based on current metrics
*/
calculateNextDelay(content, typedIndex) {
const now = Date.now();
let delay = this.metrics.baseDelayMs;
// Apply early boost during startup
if (!this.metrics.startupPhaseDone) {
delay *= this.config.typingParams.earlyBoostFactor;
}
// Adjust based on current WPM
if (this.metrics.charactersTyped > 5 && this.metrics.currentWPM > 0) {
delay = this._calculateSpeedAdjustedDelay(delay);
}
// Apply human-like variations
const humanFactor = this._applyHumanTypingPatterns(content, typedIndex);
delay *= humanFactor;
// Keep delay within reasonable bounds
delay = Utils.boundValue(
delay,
this.metrics.baseDelayMs * Constants.BEHAVIOR.MIN_DELAY_FACTOR,
this.metrics.baseDelayMs * Constants.BEHAVIOR.MAX_DELAY_FACTOR
);
this._updateDelayHistory(delay);
this.metrics.currentDelayMs = delay;
this.metrics.lastKeystrokeTime = now;
return delay;
}
/**
* Calculate delay adjustments based on WPM difference
*/
_calculateSpeedAdjustedDelay(baseDelay) {
const wpmDifference = this.metrics.currentWPM - this.config.targetWPM;
let correctionFactor = wpmDifference * this.config.typingParams.correctionStrength;
// Apply stronger correction when below target
if (wpmDifference < 0) {
correctionFactor *= this.config.typingParams.overcompensationFactor;
}
// Apply correction and offset
let delay = baseDelay * (1 + correctionFactor / 10);
delay += this.metrics.delayOffset;
// Track cumulative deviation
this.metrics.cumulativeDeviation += wpmDifference * this.config.typingParams.adaptationRate;
return this._applyTrendCorrections(delay, wpmDifference);
}
/**
* Apply corrections based on observed typing trends
*/
_applyTrendCorrections(delay, wpmDifference) {
// Apply cumulative corrections periodically
if (this.metrics.charactersTyped % 3 === 0 && Math.abs(this.metrics.cumulativeDeviation) > 0.5) {
delay *= (1 + this.metrics.cumulativeDeviation * 0.02);
// Prevent overcompensation
if (Math.abs(this.metrics.cumulativeDeviation) > 3) {
this.metrics.cumulativeDeviation *= 0.7;
}
}
// Analyze recent WPM trends
if (this.metrics.wpmHistory.length >= 3) {
const trend = this.metrics.wpmHistory.slice(-3);
const avgTrend = trend.reduce((sum, wpm) => sum + wpm, 0) / trend.length;
const trendDeviation = avgTrend - this.config.targetWPM;
// If trend consistently deviates, apply stronger correction
if (Math.abs(trendDeviation) > this.config.typingParams.allowedDeviation &&
Math.sign(trendDeviation) === Math.sign(wpmDifference)) {
delay *= (1 - (trendDeviation * 0.01));
}
}
return delay;
}
/**
* Apply human-like variations to typing rhythm
*/
_applyHumanTypingPatterns(content, typedIndex) {
// Base human factor with random variation
let humanFactor = 0.9 + (Math.random() * 0.2);
const pattern = Math.random();
const params = this.config.typingParams;
// Apply pattern-based variations (micro-pause, burst, hesitation)
const microPause = Utils.applyPatternIf(
pattern < params.microPauseChance,
(factor) => factor * (1 + Math.random() * 0.3),
humanFactor
);
if (microPause !== null) return microPause;
const burst = Utils.applyPatternIf(
pattern < params.microPauseChance + params.burstChance,
(factor) => factor * (0.75 + Math.random() * 0.1),
humanFactor
);
if (burst !== null) return burst;
const hesitation = Utils.applyPatternIf(
pattern < params.microPauseChance + params.burstChance + params.hesitationChance,
(factor) => factor * (1.1 + Math.random() * 0.4),
humanFactor
);
if (hesitation !== null) return hesitation;
// Apply content-based variations (word boundaries, common sequences)
const currentChar = content[typedIndex];
const wordBoundary = Utils.applyPatternIf(
Utils.isInArray(currentChar, AppConfig.wordBoundaries),
(factor) => Utils.applyRandomVariation(
factor,
Constants.BEHAVIOR.WORD_BOUNDARY_MIN,
Constants.BEHAVIOR.WORD_BOUNDARY_MAX
),
humanFactor
);
if (wordBoundary !== null) return wordBoundary;
let nextFewChars = content.slice(typedIndex, typedIndex + 3);
const commonSeq = Utils.applyPatternIf(
Utils.startsWithAny(nextFewChars, AppConfig.commonSequences),
(factor) => Utils.applyRandomVariation(
factor,
Constants.BEHAVIOR.COMMON_SEQ_MIN,
Constants.BEHAVIOR.COMMON_SEQ_MAX
),
humanFactor
);
if (commonSeq !== null) return commonSeq;
return humanFactor;
}
/**
* Update delay history for analysis
*/
_updateDelayHistory(delay) {
// Maintain limited history of patterns
if (this.metrics.typingPattern.length > 15) this.metrics.typingPattern.shift();
this.metrics.typingPattern.push(delay);
// Keep adjustment history for analysis
if (this.metrics.adjustmentHistory.length > 10) this.metrics.adjustmentHistory.shift();
this.metrics.adjustmentHistory.push({
wpm: this.metrics.currentWPM,
targetWpm: this.config.targetWPM,
baseDelay: this.metrics.baseDelayMs,
adjustedDelay: delay
});
}
/**
* Add random micro-pauses for human-like typing
*/
async addMicroPause() {
if (Math.random() < 0.07) {
const pauseTime = Math.random() * this.config.typingParams.maxMicroPause;
return Utils.delay(pauseTime);
}
return Promise.resolve();
}
}
// ===== ACCURACY CONTROLLER =====
/**
* Controls typing accuracy to match target percentage
*/
class AccuracyController {
constructor(metricsService, configService) {
this.metrics = metricsService;
this.config = configService;
// Use the cyclic buffer value
this.accuracyBuffer = this.config.targetAccuracyBuffer;
}
/**
* Get the current accuracy buffer for logging purposes
*/
getBufferInfo() {
return `+${Utils.formatNumber(this.accuracyBuffer, 2)}%`;
}
/**
* Determine if an error should be made to maintain target accuracy
*/
shouldMakeError() {
// Don't make errors at the beginning
if (this.metrics.totalKeystrokes === 0) return false;
// Target accuracy with buffer
const targetWithBuffer = this.config.targetAccuracy + this.accuracyBuffer;
// Dynamic error probability based on current vs. target accuracy
if (this.metrics.currentAccuracy > targetWithBuffer) {
return true; // More likely to make errors when above target
} else if (this.metrics.currentAccuracy < targetWithBuffer) {
return false; // Less likely when below target
}
// When at target accuracy, error probability matches adjusted target
return Math.random() > (targetWithBuffer / 100);
}
}
// ===== KEYBOARD HANDLER =====
/**
* Handles keyboard input and simulates keystrokes
*/
class KeyboardHandler {
constructor(metricsService, configService, eventBus) {
this.metrics = metricsService;
this.config = configService;
this.eventBus = eventBus;
}
/**
* Process keystroke and update metrics
*/
processKeystroke(appNode, makeCorrect) {
// Update metrics based on keystroke correctness
if (makeCorrect) {
this.metrics.trackCorrectKeystroke();
if (this.config.isAutoTypingMode) {
this.metrics.updateWPM(1);
}
} else {
this.metrics.trackIncorrectKeystroke();
}
// Simulate keystroke in the app
appNode.handleKeyPress("character", new KeyboardEvent("keypress", {
key: makeCorrect ? appNode.props.lessonContent[appNode.typedIndex] : "$"
}));
this._checkSessionComplete(appNode);
}
/**
* Simulate pressing Enter key
*/
simulateEnterKey(appNode) {
appNode.handleKeyPress("character", new KeyboardEvent("keypress", { key: "\n" }));
this._checkSessionComplete(appNode);
}
/**
* Check if session is complete in manual mode
*/
_checkSessionComplete(appNode) {
if (!this.config.isAutoTypingMode && this._isSessionComplete(appNode)) {
this.handleSessionCompletion();
}
}
/**
* Check if typing session is complete
*/
_isSessionComplete(appNode) {
return appNode.typedIndex >= appNode.props.lessonContent.length;
}
/**
* Handle completion of a manual typing session
*/
handleSessionCompletion() {
this.metrics.markSessionComplete();
this.eventBus.emit(Constants.EVENTS.MANUAL_SESSION_COMPLETED);
}
/**
* Create key handlers for different typing modes
*/
createKeyHandlers(appNode, originalKeyHandler, accuracyController, longestWord) {
return {
// Normal typing mode handler
createNormalHandler: () => {
return this._createNormalKeyHandler(appNode, originalKeyHandler, accuracyController, longestWord);
},
// Countdown phase handler
createCountdownHandler: () => {
return this._createCountdownKeyHandler(originalKeyHandler);
}
};
}
/**
* Create normal typing mode key handler
*/
_createNormalKeyHandler(appNode, originalKeyHandler, accuracyController, longestWord) {
return (e, n) => {
if ("character" === e) {
if (appNode.typedIndex === longestWord.index) {
this.simulateEnterKey(appNode);
return;
}
this.processKeystroke(appNode, !accuracyController.shouldMakeError());
} else if (n.key === "\n") {
this.simulateEnterKey(appNode);
} else {
return originalKeyHandler(e, n);
}
};
}
/**
* Create countdown phase key handler
*/
_createCountdownKeyHandler(originalKeyHandler) {
return (e, n) => {
// Toggle modes with different keys: 'a' for auto, 'm' for manual, 'n' for normal
if ("character" === e) {
if (n.key === "a") {
this.config.typingMode = AppModes.AUTO;
Logger.info(`Mode switched to: AUTO typing`, 'KeyboardHandler');
return;
} else if (n.key === "m") {
this.config.typingMode = AppModes.MANUAL;
Logger.info(`Mode switched to: MANUAL typing`, 'KeyboardHandler');
return;
} else if (n.key === "n") {
this.config.typingMode = AppModes.NORMAL;
Logger.info(`Mode switched to: NORMAL typing (script disabled)`, 'KeyboardHandler');
return;
}
}
// Pass through specific keys
if (n.key >= '1' && n.key <= '8' || n.key === 'Shift' || n.key === 'Control') {
return originalKeyHandler(e, n);
}
};
}
}
// ===== SESSION MANAGER =====
/**
* Manages typing session lifecycle and transitions
*/
class SessionManager {
constructor(configService, metricsService, eventBus) {
this.config = configService;
this.metrics = metricsService;
this.eventBus = eventBus;
this.isHandlingCompletion = false;
// Subscribe to session completion event
this.eventBus.on(Constants.EVENTS.SESSION_COMPLETED, data => {
if (!this.isHandlingCompletion) {
this.handleSessionCompleted(data);
}
});
}
/**
* Handle session completion and report results
*/
handleSessionCompleted(sessionData) {
this.isHandlingCompletion = true;
// Save target values before incrementing
const currentTargetWPM = this.config.targetWPM;
const currentTargetAccuracy = this.config.targetAccuracy;
// Get final metrics
const finalWPM = sessionData?.finalWPM || 0;
const finalAccuracy = sessionData?.finalAccuracy || 0;
// Log completion results
this._logSessionResults(finalWPM, finalAccuracy, currentTargetWPM, currentTargetAccuracy);
// Increment counters for next session
const newCounters = this.config.incrementCounters();
Logger.info(`New WPM session: ${newCounters.wpmSession}/${AppConfig.wpmValues.length} | New Accuracy session: ${newCounters.accuracySession}/${AppConfig.accuracies.length} | New Buffer session: ${newCounters.accuracyBufferSession}/${AppConfig.accuracyBuffers.length}`, 'SessionManager');
// Log additional metrics in auto mode
if (this.config.isAutoTypingMode) {
this.metrics.logAdjustmentHistory();
}
Logger.info("Waiting 4 seconds before refreshing page...", 'SessionManager');
// Emit refresh notification event
this.eventBus.emit(Constants.EVENTS.SESSION_COMPLETED_REFRESH, {
isAutoMode: this.config.isAutoTypingMode,
isManualMode: this.config.isManualTypingMode,
isNormalMode: this.config.isNormalTypingMode,
nextWpmSession: newCounters.wpmSession,
nextAccuracySession: newCounters.accuracySession,
nextBufferSession: newCounters.accuracyBufferSession
});
// Refresh page after delay
setTimeout(() => window.location.reload(), 4000);
}
/**
* Log session completion results
*/
_logSessionResults(finalWPM, finalAccuracy, targetWPM, targetAccuracy) {
if (this.config.isAutoTypingMode) {
Logger.success("Auto-typing completed!", 'SessionManager');
Logger.logMetric('Final WPM', finalWPM, targetWPM, 'SessionManager');
} else {
Logger.success("Manual typing session completed!", 'SessionManager');
}
Logger.logMetric('Final accuracy', finalAccuracy, targetAccuracy, 'SessionManager');
}
}
// ===== AUTO-TYPER =====
/**
* Main controller for auto-typing functionality
*/
class AutoTyper {
constructor(services) {
this.dom = services.dom;
this.config = services.config;
this.metrics = services.metrics;
this.timingController = services.timingController;
this.accuracyController = services.accuracyController;
this.keyboardHandler = services.keyboardHandler;
this.eventBus = services.eventBus;
this.sessionManager = services.sessionManager;
}
/**
* Initialize auto-typer and wait for page to load
*/
async init() {
Logger.info("Waiting for page to fully load...", 'AutoTyper');
// Retry initialization until typing app is ready
await Utils.retryUntilSuccess(() => {
const result = this.initTypingScript();
if (result) {
Logger.info("Script is now running!", 'AutoTyper');
}
return result;
}, 500);
}
/**
* Set up typing script once page is loaded
*/
initTypingScript() {
try {
this.appNode = this.dom.getTypingAppNode();
if (!this.appNode) return false;
// Get content and analyze
const content = this.appNode.props.lessonContent;
this.longestWord = Utils.getLongestWord(content);
this.originalKeyHandler = this.appNode.input.keyHandler;
// Log setup information
Logger.info("Script successfully loaded", 'AutoTyper');
Logger.logSessionInfo(this.config, 'AutoTyper');
Logger.info(`Accuracy target buffer: ${this.accuracyController.getBufferInfo()} (Session ${this.config.accuracyBufferCount}/${AppConfig.accuracyBuffers.length})`, 'AutoTyper');
Logger.info(`Longest word detected: '${this.longestWord.word}' at position ${this.longestWord.index}`, 'AutoTyper');
let modeDisplay = "UNKNOWN";
if (this.config.isAutoTypingMode) modeDisplay = "AUTO";
else if (this.config.isManualTypingMode) modeDisplay = "MANUAL";
else if (this.config.isNormalTypingMode) modeDisplay = "NORMAL (script disabled)";
Logger.info(`Mode: ${modeDisplay} typing`, 'AutoTyper');
this.startTypingSession();
return true;
} catch (error) {
Logger.info("Content not ready yet, retrying...", 'AutoTyper');
return false;
}
}
/**
* Start typing session with countdown and mode selection
*/
async startTypingSession() {
// Set up key handlers
const keyHandlers = this.keyboardHandler.createKeyHandlers(
this.appNode,
this.originalKeyHandler,
this.accuracyController,
this.longestWord
);
// Start with countdown handler for initial setup
this.appNode.input.keyHandler = keyHandlers.createCountdownHandler();
Logger.info("Press: 'a' for AUTO typing, 'm' for MANUAL typing, 'n' for NORMAL typing", 'AutoTyper');
Logger.info("Countdown started. Auto-typing will begin in 4 seconds...", 'AutoTyper');
await Utils.delay(4000);
// If in normal mode, use the original key handler and return
if (this.config.isNormalTypingMode) {
Logger.info("Starting in NORMAL mode. Script disabled.", 'AutoTyper');
this.appNode.input.keyHandler = this.originalKeyHandler;
return;
}
// Switch to normal typing handler after countdown
this.appNode.input.keyHandler = keyHandlers.createNormalHandler();
// Start appropriate typing mode
this._startTypingMode();
}
/**
* Start appropriate typing mode with proper logging
*/
_startTypingMode() {
if (this.config.isAutoTypingMode) {
Logger.info(`Starting auto-typing - Target WPM: ${this.config.targetWPM} (Session ${this.config.wpmSessionCount}/${AppConfig.wpmValues.length})`, 'AutoTyper');
Logger.info(`Base delay between keystrokes: ${Utils.formatNumber(this.metrics.baseDelayMs)}ms (with ${this.config.typingParams.speedBoost.toFixed(2)}x speed boost)`, 'AutoTyper');
this._runAutoTyper();
} else if (this.config.isManualTypingMode) {
Logger.info(`Starting manual typing - Target accuracy: ${this.config.targetAccuracy}% (Session ${this.config.accuracySessionCount}/${AppConfig.accuracies.length})`, 'AutoTyper');
}
}
/**
* Run auto-typing process character by character
*/
async _runAutoTyper() {
let currentIndex = 0;
let isTyping = true;
// Initialize WPM tracking
this.metrics.typingStartTime = Date.now();
this.metrics.lastKeystrokeTime = Date.now();
/**
* Type next character with appropriate timing
*/
const typeNextCharacter = async () => {
// Stop if typing is cancelled or complete
if (!isTyping || !this.config.isAutoTypingMode || this.config.isNormalTypingMode || this._isSessionComplete(currentIndex)) {
if (this._isSessionComplete(currentIndex)) {
this.metrics.markSessionComplete();
}
return;
}
// Calculate delay for natural typing rhythm
const delay = this.timingController.calculateNextDelay(
this.appNode.props.lessonContent,
this.appNode.typedIndex
);
// Add random micro-pauses for realism
await this.timingController.addMicroPause();
setTimeout(() => {
if (!this.config.isAutoTypingMode || this.config.isNormalTypingMode) return;
// Handle special case for longest word (press Enter)
if (currentIndex === this.longestWord.index) {
this.keyboardHandler.simulateEnterKey(this.appNode);
currentIndex++;
typeNextCharacter();
return;
}
// Determine whether to make an error
const makeError = this.accuracyController.shouldMakeError();
this.keyboardHandler.processKeystroke(this.appNode, !makeError);
// Only advance index on correct keystrokes
if (!makeError) {
currentIndex++;
}
// Continue typing next character
typeNextCharacter();
}, delay);
};
// Start the typing process
typeNextCharacter();
}
/**
* Check if typing session is complete
*/
_isSessionComplete(currentIndex) {
return currentIndex >= this.appNode.props.lessonContent.length;
}
}
// ===== SERVICE CONTAINER =====
/**
* Manages service instances and dependencies
*/
class ServiceContainer {
constructor() {
this.services = {};
}
/**
* Register a service in the container
*/
register(name, service) {
this.services[name] = service;
return this;
}
/**
* Retrieve a service from the container
*/
get(name) {
return this.services[name];
}
/**
* Create and register all services with dependencies
*/
createServices() {
// Create core services
const eventBus = new EventBus();
this.register('eventBus', eventBus);
const configService = new ConfigService(eventBus);
this.register('config', configService);
const domService = new DOMInterface();
this.register('dom', domService);
// Create dependent services
const metricsService = new MetricsService(configService, eventBus);
this.register('metrics', metricsService);
const timingController = new TimingController(metricsService, configService);
this.register('timingController', timingController);
const accuracyController = new AccuracyController(metricsService, configService);
this.register('accuracyController', accuracyController);
const keyboardHandler = new KeyboardHandler(metricsService, configService, eventBus);
this.register('keyboardHandler', keyboardHandler);
const sessionManager = new SessionManager(configService, metricsService, eventBus);
this.register('sessionManager', sessionManager);
// Create main application controller
const autoTyper = new AutoTyper(this.services);
this.register('autoTyper', autoTyper);
return this;
}
}
// ===== MAIN APP =====
/**
* Main application entry point
*/
class TypingApp {
constructor() {
// Create and initialize services
this.container = new ServiceContainer().createServices();
this.autoTyper = this.container.get('autoTyper');
}
/**
* Start the typing application
*/
async start() {
await this.autoTyper.init();
}
}
// ===== INITIALIZE THE APP =====
/**
* Self-executing function to start the application
*/
(function() {
const app = new TypingApp();
app.start();
})();