// ==UserScript==
// @name Quiz.com Slide Debug + Highlight (invisible toggle)
// @namespace quiz-debug
// @version 2.5
// @description Detect exposed correct answers from Quiz.com worker messages, invisible toggle
// @match https://quiz.com/*
// @match https://*.quiz.com/*
// @run-at document-start
// @grant unsafeWindow
// ==/UserScript==
(function () {
'use strict';
const win = unsafeWindow;
let correctAnswers = [];
let lastQuestion = '';
let highlightVisible = false; // hidden by default
console.log('[Quiz Debug] v2.5 loaded — invisible toggle, hidden by default');
// =========================================================
// Helpers
// =========================================================
function normalize(value) {
return String(value ?? '')
.replace(/\s+/g, ' ')
.trim()
.toLowerCase();
}
function setCorrectAnswers(question, answers) {
const found = answers
.filter(a => a && a.isCorrect === true)
.map(a => String(a.text ?? '').trim())
.filter(Boolean);
if (!found.length) return;
const signature =
String(question || '') + '|' + found.join('|');
const oldSignature =
lastQuestion + '|' + correctAnswers.join('|');
if (signature === oldSignature)
return;
lastQuestion = String(question || '');
correctAnswers = found;
console.log(
'%c[Quiz Debug] QUESTION:',
'color:#00bfff;font-weight:bold',
lastQuestion
);
console.log(
'%c[Quiz Debug] CORRECT:',
'color:#00ff66;font-weight:bold',
correctAnswers
);
clearHighlights();
scheduleHighlight();
}
// =========================================================
// Recursively inspect any object coming from Worker
// =========================================================
function inspect(value, depth = 0, seen = new WeakSet()) {
if (depth > 12 || value == null)
return;
if (typeof value === 'string') {
const str = value.trim();
if (str.startsWith('{') || str.startsWith('[')) {
try {
inspect(JSON.parse(str), depth + 1, seen);
} catch (_) {}
}
return;
}
if (typeof value !== 'object')
return;
if (seen.has(value))
return;
seen.add(value);
if (
Array.isArray(value.answers) &&
value.answers.some(
a =>
a &&
typeof a === 'object' &&
'isCorrect' in a
)
) {
setCorrectAnswers(value.question, value.answers);
}
if (
value.path === '/slideObject' &&
value.value &&
Array.isArray(value.value.answers)
) {
setCorrectAnswers(
value.value.question,
value.value.answers
);
}
if (Array.isArray(value)) {
for (const item of value) {
inspect(item, depth + 1, seen);
}
} else {
for (const key of Object.keys(value)) {
try {
inspect(value[key], depth + 1, seen);
} catch (_) {}
}
}
}
// =========================================================
// Highlight DOM
// =========================================================
function applyOutline(el) {
el.style.setProperty('outline', '6px solid #00ff55', 'important');
el.style.setProperty('outline-offset', '3px', 'important');
el.style.setProperty('box-shadow', '0 0 20px #00ff55', 'important');
}
function removeOutline(el) {
el.style.removeProperty('outline');
el.style.removeProperty('outline-offset');
el.style.removeProperty('box-shadow');
}
function clearHighlights() {
document
.querySelectorAll('[data-quiz-correct-highlight]')
.forEach(el => {
removeOutline(el);
el.removeAttribute('data-quiz-correct-highlight');
});
}
function highlightAnswers() {
if (!correctAnswers.length)
return;
const expected = correctAnswers.map(normalize);
const elements = Array.from(
document.querySelectorAll(
'button, [role="button"], div, span, p'
)
);
for (const answer of expected) {
let matches = elements.filter(el => {
if (el.children.length > 3) return false;
if (normalize(el.textContent) !== answer) return false;
const r = el.getBoundingClientRect();
return (
r.width > 20 &&
r.height > 10 &&
r.width < window.innerWidth * 0.8 &&
r.height < 180
);
});
if (!matches.length) {
console.log(
'[Quiz Debug] Text not found in DOM:',
answer
);
continue;
}
matches.sort((a, b) => {
const ar = a.getBoundingClientRect();
const br = b.getBoundingClientRect();
return ar.width * ar.height - br.width * br.height;
});
let target = matches[0];
let node = target;
for (
let i = 0;
i < 8 && node && node.parentElement;
i++
) {
const parent = node.parentElement;
const rect = parent.getBoundingClientRect();
const text = normalize(parent.textContent);
if (
text === answer &&
rect.width >= 120 &&
rect.height >= 30 &&
rect.height <= 140
) {
target = parent;
}
node = parent;
}
target.setAttribute('data-quiz-correct-highlight', 'true');
if (highlightVisible) {
applyOutline(target);
} else {
removeOutline(target);
}
console.log(
'%c[Quiz Debug] Marked:',
'color:#00ff55;font-weight:bold',
answer,
highlightVisible ? '(visible)' : '(hidden)',
target
);
}
}
function scheduleHighlight() {
[
0, 50, 150, 300, 600,
1000, 1500, 2500, 4000
].forEach(ms => {
setTimeout(highlightAnswers, ms);
});
}
// =========================================================
// Toggle button — invisible until hovered
// =========================================================
function makeToggleButton() {
if (document.getElementById('quiz-debug-toggle-wrap'))
return;
if (!document.body) {
setTimeout(makeToggleButton, 50);
return;
}
// invisible hover zone
const wrap = document.createElement('div');
wrap.id = 'quiz-debug-toggle-wrap';
Object.assign(wrap.style, {
position: 'fixed',
bottom: '0',
right: '0',
width: '90px',
height: '90px',
zIndex: '2147483647',
background: 'transparent',
pointerEvents: 'auto'
});
const btn = document.createElement('button');
btn.id = 'quiz-debug-toggle';
btn.type = 'button';
btn.textContent = '○';
Object.assign(btn.style, {
position: 'absolute',
bottom: '16px',
right: '16px',
width: '32px',
height: '32px',
borderRadius: '50%',
border: '2px solid #777',
background: 'rgba(0,0,0,0.55)',
color: '#777',
fontSize: '16px',
fontWeight: 'bold',
cursor: 'pointer',
padding: '0',
lineHeight: '1',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
userSelect: 'none',
opacity: '0',
transition: 'opacity 0.2s, background 0.2s, color 0.2s, border-color 0.2s',
pointerEvents: 'none'
});
function paintState() {
if (highlightVisible) {
btn.style.borderColor = '#00ff55';
btn.style.color = '#00ff55';
btn.textContent = '●';
} else {
btn.style.borderColor = '#777';
btn.style.color = '#777';
btn.textContent = '○';
}
}
paintState();
wrap.addEventListener('mouseenter', () => {
btn.style.opacity = '1';
btn.style.pointerEvents = 'auto';
});
wrap.addEventListener('mouseleave', () => {
btn.style.opacity = '0';
btn.style.pointerEvents = 'none';
});
btn.addEventListener('click', (e) => {
e.stopPropagation();
e.preventDefault();
highlightVisible = !highlightVisible;
console.log(
'[Quiz Debug] highlight visible =',
highlightVisible
);
paintState();
document
.querySelectorAll('[data-quiz-correct-highlight]')
.forEach(el => {
if (highlightVisible) {
applyOutline(el);
} else {
removeOutline(el);
}
});
});
wrap.appendChild(btn);
document.body.appendChild(wrap);
}
// =========================================================
// Hook WebSocket — safe wrapper
// =========================================================
try {
const NativeWebSocket = win.WebSocket;
function PatchedWebSocket(...args) {
const socket = new NativeWebSocket(...args);
console.log('[Quiz Debug] window WebSocket:', args[0]);
socket.addEventListener('message', event => {
try { inspect(event.data); } catch (_) {}
});
const nativeSend = socket.send;
socket.send = function (data) {
try { inspect(data); } catch (_) {}
return nativeSend.call(this, data);
};
return socket;
}
PatchedWebSocket.prototype = NativeWebSocket.prototype;
Object.setPrototypeOf(PatchedWebSocket, NativeWebSocket);
for (const k of ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED']) {
try {
Object.defineProperty(PatchedWebSocket, k, {
value: NativeWebSocket[k],
writable: false,
configurable: false
});
} catch (_) {}
}
win.WebSocket = PatchedWebSocket;
} catch (error) {
console.warn('[Quiz Debug] WebSocket hook failed:', error);
}
// =========================================================
// Hook Worker — safe wrapper
// =========================================================
try {
const NativeWorker = win.Worker;
function PatchedWorker(...args) {
console.log('[Quiz Debug] Worker created:', args[0]);
const worker = new NativeWorker(...args);
worker.addEventListener('message', event => {
try { inspect(event.data); } catch (_) {}
});
const nativePostMessage = worker.postMessage;
worker.postMessage = function (...msgArgs) {
try { inspect(msgArgs[0]); } catch (_) {}
return nativePostMessage.apply(this, msgArgs);
};
return worker;
}
PatchedWorker.prototype = NativeWorker.prototype;
Object.setPrototypeOf(PatchedWorker, NativeWorker);
win.Worker = PatchedWorker;
console.log('[Quiz Debug] Worker hook installed');
} catch (error) {
console.error('[Quiz Debug] Worker hook failed:', error);
}
// =========================================================
// Hook SharedWorker
// =========================================================
if (win.SharedWorker) {
try {
const NativeSharedWorker = win.SharedWorker;
function PatchedSharedWorker(...args) {
console.log('[Quiz Debug] SharedWorker:', args[0]);
const shared = new NativeSharedWorker(...args);
if (shared.port) {
hookMessagePort(shared.port);
try { shared.port.start(); } catch (_) {}
}
return shared;
}
PatchedSharedWorker.prototype = NativeSharedWorker.prototype;
Object.setPrototypeOf(PatchedSharedWorker, NativeSharedWorker);
win.SharedWorker = PatchedSharedWorker;
} catch (error) {
console.warn('[Quiz Debug] SharedWorker hook failed:', error);
}
}
// =========================================================
// Hook MessagePort
// =========================================================
function hookMessagePort(port) {
if (!port || port.__quizDebugHooked) return;
try {
Object.defineProperty(port, '__quizDebugHooked', { value: true });
} catch (_) { return; }
port.addEventListener('message', event => {
try { inspect(event.data); } catch (_) {}
});
const nativePostMessage = port.postMessage;
port.postMessage = function (...args) {
try { inspect(args[0]); } catch (_) {}
return nativePostMessage.apply(this, args);
};
}
// =========================================================
// Hook MessageChannel
// =========================================================
try {
const NativeMessageChannel = win.MessageChannel;
if (NativeMessageChannel) {
function PatchedMessageChannel(...args) {
const channel = new NativeMessageChannel(...args);
hookMessagePort(channel.port1);
hookMessagePort(channel.port2);
return channel;
}
PatchedMessageChannel.prototype = NativeMessageChannel.prototype;
Object.setPrototypeOf(PatchedMessageChannel, NativeMessageChannel);
win.MessageChannel = PatchedMessageChannel;
}
} catch (_) {}
// =========================================================
// React rerender observer
// =========================================================
const observer = new MutationObserver(() => {
if (correctAnswers.length) {
highlightAnswers();
}
});
function startObserver() {
if (!document.documentElement) {
setTimeout(startObserver, 20);
return;
}
observer.observe(document.documentElement, {
childList: true,
subtree: true
});
}
startObserver();
// =========================================================
// Boot the toggle button
// =========================================================
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', makeToggleButton);
} else {
makeToggleButton();
}
setInterval(() => {
if (!document.getElementById('quiz-debug-toggle-wrap')) {
makeToggleButton();
}
}, 1000);
})();
