Action Required
XP Farm is currently running. Do you want to stop it to run Auto League?
Native Mode
${icons.settingsBtn}
How many streak days to restore?
How many path lessons to solve?
How many practice lessons to solve?
Settings
Configure script preferences
Loop Interval
Delay interval between loops
XP Overshoot
Extra XP buffer (30–500 XP, 0 to disable)
Notification Position
Set the notification pop-up position
Bottom Center${icons.chevron}
Top Left
Top Center
Top Right
Bottom Left
Bottom Center
Bottom Right
On-Client Duolingo Max
Unlock Duolingo Max client-side
Safe Streak Farming
Prevent streak days from exceeding account age
EZ Quiz
Enable custom lessons and instant stories
EZ Quiz Question Count
Set the question count for custom lessons
5${icons.chevron}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Automations
${icons.arrowRight}
Auto Solver
${icons.arrowRight}
Automations
Configure automated background tasks
Auto Join League
Automatically join a league on startup
Auto Block League
Automatically block league users on startup
Auto Reach Rank
Automatically farm to target rank on startup
Auto Keep Streak
Automatically maintain streak on startup
Auto Quest Saver
Automatically complete quests on startup
About DuoXJS
Your session metrics and credits
XP Summaries
Your recent XP history
Quest Center
Manage and view your daily quests
Quest Operations
Account Manager
Switch and manage saved profiles
Saved Profiles
EULA & TOS
Please read and accept
Loading terms...
Social Tools
Interact with other Duolingo users
Block / Unblock
Block or unblock the specified user
Follow / Unfollow
Follow or unfollow the specified user
Send Gift
Gift an item to the specified user
Friend Streak / Quest
Start a Friends Quest or Friends Streak
Mass Follow
Follow or unfollow in bulk
Mass Block
Block or unblock your league
Privacy Status
Change privacy status
})
Leaderboard
Your current league
Set your status
${icons.arrowRight}
Activity Feed
Recent activity from your friends
Auto Solver
Configure question auto-solving settings
Show Solve Buttons
Show Solve/Solve All buttons in footer
Auto Solve Mode
Solve questions automatically on start
Random Speed
Wait a random delay before solving
Solve Speed (Fixed)
Delay if random speed is disabled
Min Solve Speed
Minimum delay for random speed
Max Solve Speed
Maximum delay for random speed
`;
if (typeof GM_addStyle === "function") {
GM_addStyle(`${mainCss}${loadCss}`);
} else {
document.head.insertAdjacentHTML(
"beforeend",
``,
);
}
document.body.insertAdjacentHTML(
"beforeend",
`';
for (let line of lines) {
line = line.trim();
if (line.startsWith("* ") || line.startsWith("- ")) {
const text = line.replace(/^[\*\-]\s+/, "");
const parsedText = text.replace(
/\*\*(.*?)\*\*/g,
'
$1',
);
listHtml += `
`;
} else if (/^\d+\.\s+/.test(line)) {
const num = line.match(/^(\d+)\.\s+/)[1];
const text = line.replace(/^\d+\.\s+/, "");
const parsedText = text.replace(
/\*\*(.*?)\*\*/g,
'
$1',
);
listHtml += `
`;
}
}
listHtml += "
Loading terms & conditions...
',
statusText,
!termsAccepted,
acceptLabel,
onAccept,
);
Promise.all([
window
.fetch("https://raw.githubusercontent.com/LibreDuo/DuoXJS/main/EULA.md")
.then((r) => {
if (!r.ok) throw new Error("HTTP error " + r.status);
return r.text();
}),
window
.fetch("https://raw.githubusercontent.com/LibreDuo/DuoXJS/main/TOS.md")
.then((r) => {
if (!r.ok) throw new Error("HTTP error " + r.status);
return r.text();
}),
])
.then(([eula, tos]) => {
if (eula.trim() && tos.trim()) {
updateTermsPage(
parseMarkdownToHtml(`${eula}\n\n---\n\n${tos}`),
statusText,
!termsAccepted,
acceptLabel,
onAccept,
);
} else {
throw new Error("Empty response");
}
})
.catch(() => {
const fallbackMd = `# END USER LICENSE AGREEMENT & TERMS OF SERVICE\n\nUsage of DuoXJS implies compliance with the terms below:\n\n1. **Disclaimer**: You agree to use this script at your own risk. The authors are not responsible for any account bans, suspensions, or data loss.\n2. **Usage Limit**: You will not use the script for commercial purposes or distribute malicious modifications.\n3. **License**: The script is provided "as is" under the MIT license.\n\n---\n\nPlease connect to the internet to read the full EULA and TOS from our official repository.`;
updateTermsPage(
parseMarkdownToHtml(fallbackMd),
statusText,
!termsAccepted,
acceptLabel,
onAccept,
);
});
}
async function connect(isBgProcess = false) {
if (connectBusy) {
return;
}
connectBusy = true;
token = getToken();
if (!token) {
userId = null;
headers = null;
user = null;
questState = null;
currentStatus = null;
stopLeaguePolling();
updateUi("logged_out");
connectBusy = false;
return;
}
const decoded = readToken(token);
if (!decoded) {
token = null;
userId = null;
headers = null;
user = null;
questState = null;
currentStatus = null;
stopLeaguePolling();
updateUi("logged_out");
connectBusy = false;
return;
}
userId = decoded.sub;
headers = setHeaders(token);
oldToken = token;
leagueJoinAttempted = false;
autoBlockCohortKey = null;
try {
if (!isBgProcess) {
updateUi("connecting");
}
const res = await fetchApi(
"GET",
`${config.api.users}/${userId}?fields=id,username,email,emailVerified,fromLanguage,learningLanguage,streak,totalXp,gems,picture,streakData,timezone,creationDate`,
);
if (res.status !== 200) {
throw new Error("Connection failed");
}
user = safeJsonParse(res.responseText);
if (!user) {
throw new Error("Invalid user response");
}
updateUi("connected");
showUser();
startLeaguePolling();
[
"DX_XP_Btn",
"DX_Gem_Btn",
"DX_Streak_Btn",
"DX_League_Btn",
"DX_Quest_Force_Btn",
"DX_Block_Btn",
"DX_FollowSingle_Btn",
"DX_Follow_Btn",
"DX_Block_Mass_Btn",
"DX_Gift_Btn",
"DX_Hearts_Btn",
"DX_Friend_Btn",
"DX_AutoPath_Btn",
"DX_AutoPractice_Btn",
].forEach((id) => {
const element = document.getElementById(id);
if (element) {
element.disabled = false;
}
});
setTimeout(async () => {
await Promise.allSettled([getShop(), getQuests(), getPrivacy()]);
autoKeepStreak();
autoQuestSaver();
}, 500);
} catch {
if (!isBgProcess) {
setTimeout(() => {
connect(false);
}, 5000);
}
} finally {
connectBusy = false;
}
}
const statKeys = {
xp: "dx_stat_xp_" + dxVersion,
gems: "dx_stat_gems_" + dxVersion,
streak: "dx_stat_streak_" + dxVersion,
};
const statSinceKey = "dx_stat_since_" + dxVersion;
function readStat(kind) {
return parseInt(localStorage.getItem(statKeys[kind])) || 0;
}
function showStats() {
const map = {
xp: "DX_Stat_XP",
gems: "DX_Stat_Gems",
streak: "DX_Stat_Streak",
};
for (const kind in map) {
const el = document.getElementById(map[kind]);
if (el) {
el.textContent = readStat(kind).toLocaleString();
}
}
const sinceEl = document.getElementById("DX_Stat_Since");
if (sinceEl) {
let ts = parseInt(localStorage.getItem(statSinceKey));
if (!ts) {
ts = Date.now();
localStorage.setItem(statSinceKey, String(ts));
}
sinceEl.textContent = new Date(ts).toLocaleDateString(undefined, {
month: "short",
day: "numeric",
year: "numeric",
});
}
}
let changelogBusy = false;
async function loadChangelog() {
const cont = document.getElementById("DX_Changelog");
if (!cont || changelogBusy) return;
changelogBusy = true;
if (cont.dataset.loaded !== "1") {
cont.innerHTML = `Loading changelog...
`;
}
try {
const res = await fetchApi(
"GET",
"https://raw.githubusercontent.com/LibreDuo/DuoXJS/main/CHANGELOG.md?_c=" +
Date.now(),
null,
{},
);
if (res.status !== 200) throw new Error("Changelog not found");
const text = res.responseText || "";
const lines = text.split("\n");
const items = [];
let inTargetSection = false;
for (let line of lines) {
line = line.trim();
if (line.startsWith("## ")) {
const headingVersion = line
.replace(/^##\s*/, "")
.replace(/[\[\]]/g, "")
.trim();
inTargetSection =
compareVersions(headingVersion, dxScriptVersion) === 0;
} else if (
inTargetSection &&
(line.startsWith("- ") || line.startsWith("* "))
) {
items.push(line.substring(2).trim());
}
}
const html = items.length
? `No changelog entries for this version.
`;
cont.dataset.loaded = "1";
const card = document.getElementById("DX_Changelog_Card");
if (card) {
if (html) {
card.style.display = "block";
} else {
card.style.display = "none";
}
}
} catch (e) {
const card = document.getElementById("DX_Changelog_Card");
if (card) card.style.display = "none";
} finally {
changelogBusy = false;
}
}
async function loadXpHistory() {
const cont = document.getElementById("DX_XPHistory");
if (!cont || !token || !userId || xpHistoryBusy) return;
xpHistoryBusy = true;
if (cont.dataset.loaded !== "1") {
cont.innerHTML = `Loading...
`;
}
try {
const d = new Date(Date.now() - 7 * 86400000);
const pad = (n) => String(n).padStart(2, "0");
const startDate = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
const res = await fetchApi(
"GET",
`https://www.duolingo.com/2017-06-30/users/${userId}/xp_summaries?startDate=${startDate}&_=${Date.now()}`,
);
if (res.status !== 200) throw new Error("bad status");
let summaries = (
safeJsonParse(res.responseText, {}).summaries || []
).slice();
summaries.sort((a, b) => (b.date || 0) - (a.date || 0));
summaries = summaries.slice(0, 7).reverse();
if (!summaries.length) {
cont.innerHTML = `No recent activity.
`;
cont.dataset.loaded = "1";
return;
}
cont.innerHTML = summaries
.map((s) => {
const label = new Date((s.date || 0) * 1000).toLocaleDateString(
undefined,
{ weekday: "short", month: "short", day: "numeric" },
);
return `Failed to load XP history.
`;
}
} finally {
xpHistoryBusy = false;
}
}
function compactRelativeTime(diffSec) {
diffSec = Math.max(0, Math.floor(diffSec));
if (diffSec < 60) return "just now";
const mins = Math.floor(diffSec / 60);
if (mins < 60) return `${mins}m ago`;
const hours = Math.floor(mins / 60);
if (hours < 24) return `${hours}h ago`;
const days = Math.floor(hours / 24);
if (days < 7) return `${days}d ago`;
const weeks = Math.floor(days / 7);
if (weeks < 5) return `${weeks}w ago`;
const months = Math.floor(days / 30);
if (months < 12) return `${months}mo ago`;
return `${Math.floor(months / 12)}y ago`;
}
function normalizeRelativeText(value) {
const raw = String(value == null ? "" : value).trim();
if (!raw) return "";
if (/^just now$/i.test(raw)) return "just now";
const match = raw.match(
/^(\d+)\s*(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|months?|mos?|years?|yrs?|y)(?:\s+ago)?$/i,
);
if (!match) return "";
const amount = parseInt(match[1], 10);
const unit = match[2].toLowerCase();
if (unit.startsWith("sec") || unit === "s")
return amount < 60 ? "just now" : `${Math.floor(amount / 60)}m ago`;
if (unit.startsWith("min") || unit === "m") return `${amount}m ago`;
if (unit.startsWith("h")) return `${amount}h ago`;
if (unit.startsWith("d")) return `${amount}d ago`;
if (unit.startsWith("w")) return `${amount}w ago`;
if (unit.startsWith("mo")) return `${amount}mo ago`;
if (unit.startsWith("y")) return `${amount}y ago`;
return "";
}
function feedTimestampMs(card) {
const fields = [
card?.subtitle,
card?.timestamp,
card?.createdAt,
card?.creationDate,
card?.eventTime,
card?.time,
card?.date,
];
for (const value of fields) {
if (value === undefined || value === null || value === "") continue;
if (typeof value === "number" || /^\d+$/.test(String(value).trim())) {
const num = Number(value);
if (Number.isFinite(num) && num > 0) {
return num < 100000000000 ? num * 1000 : num;
}
}
const raw = String(value).trim();
const isoLike = raw.match(
/^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(?:\s*(Z|[+-]\d{2}:?\d{2}))?$/,
);
if (isoLike) {
const hasZone = !!isoLike[8];
const normalized = raw
.replace(" ", "T")
.replace(/([+-]\d{2})(\d{2})$/, "$1:$2");
const parsed = hasZone
? Date.parse(normalized)
: Date.UTC(
+isoLike[1],
+isoLike[2] - 1,
+isoLike[3],
+isoLike[4],
+isoLike[5],
+isoLike[6],
isoLike[7] ? Number((isoLike[7] + "000").slice(0, 3)) : 0,
);
if (!Number.isNaN(parsed)) return parsed;
}
const parsed = Date.parse(raw);
if (!Number.isNaN(parsed)) return parsed;
}
return null;
}
function feedTimeAgo(card) {
const subtitleRelative = normalizeRelativeText(card?.subtitle);
if (subtitleRelative) return subtitleRelative;
const ts = feedTimestampMs(card);
if (!ts) return "";
return compactRelativeTime((Date.now() - ts) / 1000);
}
async function getFeed() {
const cont = document.getElementById("DX_Feed_Container");
if (!cont || !token || !userId || feedBusy) return;
feedBusy = true;
const loaded = cont.dataset.loaded === "1";
if (!loaded)
cont.innerHTML = `Loading...
`;
try {
const res = await fetchApi(
"GET",
`https://www.duolingo.com/2017-06-30/friends/users/${userId}/feed/v2?uiLanguage=${uiLang()}`,
);
if (res.status !== 200) throw new Error("bad status");
const cards = [];
(safeJsonParse(res.responseText, {}).feed || []).forEach((section) => {
(section.feedCards || []).forEach((c) => cards.push(c));
});
if (!cards.length) {
cont.innerHTML = `No recent activity.
`;
cont.dataset.loaded = "1";
return;
}
const frag = document.createDocumentFragment();
cards.slice(0, 40).forEach((c) => {
const name = escapeHtml(c.displayName || "Someone");
const cardType = c.cardType || "";
let message;
if (cardType === "FOLLOW") {
message = `You followed ${c.displayName || "someone"}`;
} else if (cardType === "FOLLOW_BACK") {
message = `${c.displayName || "Someone"} followed you`;
} else {
message = c.body || "";
}
const text = escapeHtml(message);
const timeAgo = escapeHtml(feedTimeAgo(c));
const raw = c.avatarUrl || c.picture || "";
const av = raw
? (raw.indexOf("http") === 0 ? raw : "https:" + raw) + "/xlarge"
: "";
const row = document.createElement("div");
row.className = "DX_HStack_4";
row.style.cssText =
"align-self: stretch; padding: 8px 10px; border-radius: var(--DX-r-s); corner-shape: var(--DX-corner); gap: 8px; background: var(--dx-card-bg);";
row.innerHTML = `
Failed to load feed.
`;
} finally {
feedBusy = false;
}
}
function addStat(kind, amount) {
if (!statKeys[kind] || !amount || amount <= 0) {
return;
}
localStorage.setItem(statKeys[kind], String(readStat(kind) + amount));
showStats();
}
function showUser() {
if (!user) {
return;
}
const usernameEl = document.getElementById("DX_UName");
if (usernameEl) {
usernameEl.textContent = user.username || "";
}
const xpEl = document.getElementById("DX_UXP");
if (xpEl) {
xpEl.textContent = (user.totalXp || 0).toLocaleString();
}
const gemsEl = document.getElementById("DX_UGems");
if (gemsEl) {
gemsEl.textContent = (user.gems || 0).toLocaleString();
}
const streakEl = document.getElementById("DX_UStreak");
if (streakEl) {
streakEl.textContent = (user.streak || 0).toLocaleString();
}
const userRowEl = document.getElementById("DX_User_Row");
if (userRowEl) {
userRowEl.style.display = "flex";
const userRowDiv = document.getElementById("DX_User_Row_Divider");
if (userRowDiv) userRowDiv.style.display = "block";
const statsRow = document.getElementById("DX_User_Stats_Row");
if (statsRow) statsRow.style.display = "flex";
const countEl = document.getElementById("DX_UAccCount");
if (countEl) countEl.style.display = "none";
}
const picUrl = bestAvatarUrl(user.picture);
const avatarEl = document.getElementById("DX_Avatar");
if (avatarEl) {
const currentImg = avatarEl.querySelector("img");
if (!currentImg || currentImg.src !== picUrl) {
const img = document.createElement("img");
img.src = picUrl;
img.style.cssText =
"width: 100%; height: 100%; object-fit: cover; border-radius: 50%;";
img.addEventListener("error", () => {
avatarEl.innerHTML = icons.avatar;
});
avatarEl.replaceChildren(img);
}
}
}
let accountStatsTs = 0;
const ACCOUNT_STATS_TTL = 30000;
async function refreshStats(force = false) {
if (!token || !userId || !user || refreshStatsBusy) {
return;
}
if (!force && Date.now() - accountStatsTs < ACCOUNT_STATS_TTL) {
return;
}
refreshStatsBusy = true;
try {
const res = await fetchApi(
"GET",
`${config.api.users}/${userId}?fields=streak,totalXp,gems,streakData,creationDate`,
);
if (res.status === 200) {
const data = safeJsonParse(res.responseText, {});
if (data.totalXp !== undefined) {
user.totalXp = data.totalXp;
}
if (data.gems !== undefined) {
user.gems = data.gems;
}
if (data.streak !== undefined) {
user.streak = data.streak;
}
if (data.streakData !== undefined) {
user.streakData = data.streakData;
}
if (data.creationDate !== undefined) {
user.creationDate = data.creationDate;
}
accountStatsTs = Date.now();
showUser();
}
} catch {
} finally {
refreshStatsBusy = false;
}
}
function accountTimezone() {
return user && user.timezone ? user.timezone : "America/New_York";
}
function uiLang() {
return user && user.fromLanguage ? user.fromLanguage : "en";
}
function tzParts(timeZone, date) {
const dtf = new Intl.DateTimeFormat("en-US", {
timeZone: timeZone,
hourCycle: "h23",
year: "numeric",
month: "2-digit",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
second: "2-digit",
});
const out = {};
dtf.formatToParts(date).forEach((part) => {
if (part.type !== "literal") out[part.type] = part.value;
});
return out;
}
function wallClockToSeconds(
timeZone,
year,
month,
day,
hour,
minute,
second,
) {
const guess = Date.UTC(year, month - 1, day, hour, minute, second);
const parts = tzParts(timeZone, new Date(guess));
const localAsUtc = Date.UTC(
+parts.year,
+parts.month - 1,
+parts.day,
+parts.hour,
+parts.minute,
+parts.second,
);
const offset = localAsUtc - guess;
return Math.floor((guess - offset) / 1000);
}
function accountToday(timeZone) {
const parts = tzParts(timeZone, new Date());
return { year: +parts.year, month: +parts.month, day: +parts.day };
}
function accountNowIso() {
const now = new Date();
const parts = tzParts(accountTimezone(), now);
const ms = String(now.getMilliseconds()).padStart(3, "0");
return `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:${parts.second}.${ms}Z`;
}
async function playStory(bonus, signal) {
try {
const currentSeconds = Math.floor(Date.now() / 1000);
const genDuration = Math.floor(Math.random() * 121 + 300);
const payload = {
awardXp: true,
completedBonusChallenge: true,
fromLanguage: "en",
learningLanguage: "fr",
hasXpBoost: false,
illustrationFormat: "svg",
isFeaturedStoryInPracticeHub: true,
isLegendaryMode: true,
isV2Redo: false,
isV2Story: false,
masterVersion: true,
maxScore: 0,
score: 0,
happyHourBonusXp: bonus,
startTime: currentSeconds,
endTime: currentSeconds + genDuration,
};
const res = await fetchApi(
"POST",
`${config.api.stories}/fr-en-le-passeport/complete`,
payload,
null,
signal,
);
if (res.status !== 200) return false;
const data = safeJsonParse(res.responseText, {});
return !!data.awardedXp;
} catch {
return false;
}
}
async function farmXp(targetAmount) {
const isInfinite = targetAmount === Infinity;
if (!isInfinite) {
const room = parseInt(localStorage.getItem("dx_xp_room")) || 0;
if (room > 0) {
targetAmount += Math.min(500, Math.max(30, room));
}
}
const maxPerReq = 499;
const minPerReq = 30;
let loops = isInfinite ? Infinity : Math.floor(targetAmount / maxPerReq);
let remAmount = isInfinite ? 0 : targetAmount % maxPerReq;
if (!isInfinite && remAmount > 0 && remAmount < minPerReq && loops > 0) {
loops--;
remAmount += maxPerReq;
}
const expectedIters = isInfinite
? Infinity
: loops + (remAmount >= minPerReq ? 1 : 0);
let doneIters = 0;
let totalXp = 0;
const sig = farmSignal("xp");
stopBtn("DX_XP_Btn");
try {
for (let i = 0; i < loops; i++) {
if (!farmStates.xp) {
break;
}
const success = await playStory(469, sig);
if (!farmStates.xp) break;
if (success) {
totalXp += maxPerReq;
doneIters++;
user.totalXp += maxPerReq;
showUser();
}
if (!isInfinite) {
setProgress("DX_XP", (doneIters / expectedIters) * 100);
}
await waitStop(delayMs, sig);
}
if (!isInfinite && remAmount >= minPerReq && farmStates.xp) {
const success = await playStory(
Math.min(remAmount - minPerReq, 469),
sig,
);
if (success) {
totalXp += remAmount;
doneIters++;
user.totalXp += remAmount;
showUser();
}
setProgress("DX_XP", 100);
}
const completed = farmStates.xp;
if (totalXp > 0) {
addStat("xp", totalXp);
notify(
"success",
completed ? "XP Farm Complete" : "XP Farm Stopped",
`Farmed ${totalXp} XP.`,
);
refreshStats(true);
}
clearProgress("DX_XP", completed);
} finally {
farmStates.xp = false;
farmCtl.xp = null;
resetBtn("DX_XP_Btn", "RUN");
}
}
async function checkGems(signal) {
try {
const res = await fetchApi(
"GET",
`https://www.duolingo.com/2023-05-23/users/${userId}?fields=rewardBundles{rewards}`,
null,
null,
signal,
);
if (res.status !== 200) {
return [];
}
const data = safeJsonParse(res.responseText, {});
const collected = [];
for (const bundle of data.rewardBundles || []) {
for (const reward of bundle.rewards || []) {
if (
!reward.consumed &&
((reward.id || "").startsWith("SKILL_COMPLETION-") ||
(reward.id || "").startsWith("SKILL_COMPLETION_BALANCED-"))
) {
collected.push({ id: reward.id, amount: reward.amount || 0 });
}
}
}
return collected;
} catch {
return [];
}
}
async function claimGem(rewardId, signal) {
const payload = {
consumed: true,
fromLanguage: user.fromLanguage,
learningLanguage: user.learningLanguage,
};
try {
let res = await fetchApi(
"PATCH",
`https://www.duolingo.com/2023-05-23/users/${userId}/rewards/${rewardId}`,
payload,
null,
signal,
);
return res.status === 200;
} catch {
return false;
}
}
async function farmGems(targetLoops) {
const isInfinite = targetLoops === Infinity;
stopBtn("DX_Gem_Btn");
let totalGained = 0;
let doneLoops = 0;
const sig = farmSignal("gem");
try {
while (farmStates.gem && (isInfinite || doneLoops < targetLoops)) {
let available = await checkGems(sig);
if (!farmStates.gem) break;
if (available.length === 0) {
await waitStop(delayMs * 2, sig);
continue;
}
if (farmStates.gem && (isInfinite || doneLoops < targetLoops)) {
const results = await Promise.all(
available.map((r) => claimGem(r.id, sig)),
);
if (!farmStates.gem) break;
let batchGained = 0;
results.forEach((ok, idx) => {
if (ok) batchGained += available[idx].amount || 0;
});
if (batchGained > 0) {
totalGained += batchGained;
if (user) {
user.gems = (user.gems || 0) + batchGained;
showUser();
}
}
await waitStop(150, sig);
doneLoops++;
if (!isInfinite) {
setProgress("DX_Gem", (doneLoops / targetLoops) * 100);
}
await waitStop(Math.max(50, delayMs - 50), sig);
}
await waitStop(delayMs, sig);
}
const completed = farmStates.gem;
if (totalGained > 0) {
addStat("gems", totalGained);
notify(
"success",
completed ? "Gem Farm Complete" : "Gem Farm Stopped",
`+${totalGained} gems acquired.`,
);
refreshStats(true);
}
clearProgress("DX_Gem", completed);
} finally {
farmStates.gem = false;
farmCtl.gem = null;
resetBtn("DX_Gem_Btn", "RUN");
}
}
async function completePracticeSession(endSecs, signal) {
try {
const sPayload = {
challengeTypes: config.challengeTypes,
fromLanguage: user.fromLanguage,
isFinalLevel: false,
isV2: true,
juicy: true,
learningLanguage: user.learningLanguage,
smartTipsVersion: 2,
type: "GLOBAL_PRACTICE",
};
const sRes = await fetchApi(
"POST",
config.api.sessions,
sPayload,
null,
signal,
);
if (sRes.status !== 200) {
return false;
}
const sData = safeJsonParse(sRes.responseText, {});
if (!sData.id) {
return false;
}
const fPayload = {
...sData,
heartsLeft: 5,
startTime: endSecs - 1,
endTime: endSecs,
enableBonusPoints: false,
failed: false,
maxInLessonStreak: 9,
shouldLearnThings: true,
};
const fRes = await fetchApi(
"PUT",
`${config.api.sessions}/${sData.id}`,
fPayload,
null,
signal,
);
if (fRes.status !== 200) {
return false;
}
const fData = safeJsonParse(fRes.responseText, {});
if (fData.xpGain === undefined || fData.xpGain === null) {
return false;
}
return true;
} catch {
return false;
}
}
async function farmStreak(targetDays) {
let isInfinite = targetDays === Infinity;
stopBtn("DX_Streak_Btn");
if (localStorage.getItem("dx_safe_streak") === "true" && user) {
let creationDateVal = user.creationDate;
if (creationDateVal) {
const creationDateObj = new Date(
typeof creationDateVal === "number"
? creationDateVal * 1000
: creationDateVal,
);
if (!isNaN(creationDateObj.getTime())) {
const safeTz = accountTimezone();
const creationParts = tzParts(safeTz, creationDateObj);
const creationDayMs = Date.UTC(
+creationParts.year,
+creationParts.month - 1,
+creationParts.day,
);
const todayParts = accountToday(safeTz);
const todayDayMs = Date.UTC(
todayParts.year,
todayParts.month - 1,
todayParts.day,
);
const elapsedDays = Math.round(
(todayDayMs - creationDayMs) / 86400000,
);
const maxSafeStreak = elapsedDays;
const currentStreak = user.streak || 0;
const remainingSafeDays = Math.max(0, maxSafeStreak - currentStreak);
if (remainingSafeDays <= 0) {
notify(
"error",
"Safe Streak",
"Farming blocked: your streak has already reached the maximum limit of " +
maxSafeStreak +
" days for your account age.",
);
farmStates.streak = false;
resetBtn("DX_Streak_Btn", "RUN");
return;
}
if (isInfinite || targetDays > remainingSafeDays) {
notify(
"warning",
"Safe Streak",
"Target days capped at " +
remainingSafeDays +
" to prevent exceeding account age.",
);
targetDays = remainingSafeDays;
isInfinite = false;
}
}
}
}
const tz = accountTimezone();
let base;
const dateStr = user.streakData?.currentStreak?.startDate;
if (dateStr && /^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
const parts = dateStr.split("-").map(Number);
base = { year: parts[0], month: parts[1], day: parts[2] };
} else {
base = accountToday(tz);
}
let doneLoops = 0;
let savedDays = 0;
const sig = farmSignal("streak");
try {
while (farmStates.streak && (isInfinite || doneLoops < targetDays)) {
const endSecs = wallClockToSeconds(
tz,
base.year,
base.month,
base.day - 1 - doneLoops,
12,
0,
0,
);
if (farmStates.streak) {
const ok = await completePracticeSession(endSecs, sig);
if (ok && user) {
savedDays++;
user.streak++;
showUser();
}
}
doneLoops++;
if (!isInfinite) {
setProgress("DX_Streak", (doneLoops / targetDays) * 100);
}
await waitStop(delayMs, sig);
}
const completed = farmStates.streak;
if (savedDays > 0) {
addStat("streak", savedDays);
notify(
"success",
completed ? "Streak Restored" : "Streak Farm Stopped",
`Processed ${savedDays} days.`,
);
refreshStats(true);
} else if (completed && doneLoops > 0) {
notify(
"error",
"Streak Farm",
"No days could be saved. Please try again.",
);
}
clearProgress("DX_Streak", completed);
} finally {
farmStates.streak = false;
farmCtl.streak = null;
resetBtn("DX_Streak_Btn", "RUN");
}
}
async function keepStreak() {
if (!user) return false;
const endSecs = Math.floor(Date.now() / 1000);
return completePracticeSession(endSecs);
}
async function autoKeepStreak() {
if (localStorage.getItem("dx_auto_keep_streak") !== "true") return;
if (!user || streakKeepBusy) return;
const tz = accountTimezone();
const t = accountToday(tz);
const pad = (n) => String(n).padStart(2, "0");
const todayIso = `${t.year}-${pad(t.month)}-${pad(t.day)}`;
const keptKey = `dx_streak_kept_date_${userId}`;
if (localStorage.getItem(keptKey) === todayIso) return;
if (user.streakData?.currentStreak?.lastExtendedDate === todayIso) {
localStorage.setItem(keptKey, todayIso);
return;
}
if (localStorage.getItem("dx_safe_streak") === "true") {
let creationDateVal = user.creationDate;
if (creationDateVal) {
const creationDateObj = new Date(
typeof creationDateVal === "number"
? creationDateVal * 1000
: creationDateVal,
);
if (!isNaN(creationDateObj.getTime())) {
const creationParts = tzParts(tz, creationDateObj);
const creationDayMs = Date.UTC(
+creationParts.year,
+creationParts.month - 1,
+creationParts.day,
);
const todayDayMs = Date.UTC(t.year, t.month - 1, t.day);
const elapsedDays = Math.round(
(todayDayMs - creationDayMs) / 86400000,
);
const maxSafeStreak = elapsedDays;
const currentStreak = user.streak || 0;
if (currentStreak + 1 > maxSafeStreak) {
notify(
"warning",
"Auto Keep Streak",
"Auto streak blocked: keeping streak today would exceed the safe limit (" +
maxSafeStreak +
" days) for your account age.",
);
return;
}
}
}
}
streakKeepBusy = true;
try {
const ok = await keepStreak();
if (ok) {
localStorage.setItem(keptKey, todayIso);
refreshStats(true);
notify("success", "Auto Keep Streak", "Your streak is safe for today.");
} else {
notify(
"error",
"Auto Keep Streak",
"Could not save your streak today. Will keep retrying.",
);
}
} finally {
streakKeepBusy = false;
}
}
async function autoReachRank(knownRank) {
if (localStorage.getItem("dx_auto_reach_rank") !== "true") return;
if (!userId || farmStates.league) return;
const target = parseInt(localStorage.getItem("dx_league_target")) || 1;
const rank = knownRank === undefined ? await getLeagueRank() : knownRank;
if (rank && rank > target) {
notify("info", "Auto Reach Rank", `Climbing to #${target}...`);
farmStates.league = true;
farmCtl.league = new AbortController();
farmLeague(target);
}
}
async function autoBlockLeague() {
if (localStorage.getItem("dx_auto_block_league") !== "true") return;
if (!userId || farmStates.blockmass || farmStates.unblock) return;
farmStates.blockmass = true;
try {
const result = await blockLeagueUsers({ auto: true });
if (!result.skipped && result.ok > 0) {
notify(
"success",
"Auto Block League",
`Blocked ${result.ok} league user(s).`,
);
}
} finally {
clearProgress("DX_Block_Mass", true);
farmStates.blockmass = false;
resetBtn("DX_Block_Mass_Btn", "RUN");
}
}
async function autoQuestSaver() {
if (localStorage.getItem("dx_auto_quest_saver") !== "true") return;
if (!token || !userId || questSaverBusy) return;
questSaverBusy = true;
try {
if (!questState) return;
const schemaGoals = Array.isArray(questState.schema?.goals)
? questState.schema.goals
: [];
if (schemaGoals.length === 0) return;
const t = accountToday(accountTimezone());
const pad = (n) => String(n).padStart(2, "0");
const monthlyKey = `${t.year}_${pad(t.month)}_monthly_challenge`;
const progress = questState.progress || {};
const keys = Object.keys(progress).filter((k) => k !== monthlyKey);
if (keys.length === 0 || !keys.some((k) => progress[k] === 0)) return;
const mSet = new Set();
schemaGoals.forEach((goal) => {
if (goal.metric && goal.metric !== "QUESTS") mSet.add(goal.metric);
});
if (mSet.size === 0) return;
const monthPrefix = `${t.year}_${pad(t.month)}_monthly`;
let monthlyThreshold = 0;
schemaGoals.forEach((goal) => {
if (goal.goalId && goal.goalId.startsWith(monthPrefix)) {
monthlyThreshold = Math.max(monthlyThreshold, goal.threshold || 0);
}
});
let monthlyProgress = 0;
Object.keys(progress).forEach((k) => {
if (!k.startsWith(monthPrefix)) return;
const rd = progress[k];
const v =
typeof rd === "number" ? rd : rd && rd.progress ? rd.progress : 0;
if (v > monthlyProgress) monthlyProgress = v;
});
const targetDay =
monthlyThreshold > 0 ? Math.min(t.day, monthlyThreshold) : t.day;
const questQty = Math.max(0, targetDay - monthlyProgress);
const updates = [...mSet].map((mName) => ({
metric: mName,
quantity: 2000,
}));
if (questQty > 0) updates.push({ metric: "QUESTS", quantity: questQty });
const bPayload = {
metric_updates: updates,
timezone: accountTimezone(),
timestamp: accountNowIso(),
};
const res = await fetchApi(
"POST",
`${config.api.goals}/users/${userId}/progress/batch`,
bPayload,
setGoalHeaders(token),
);
if (res.status === 200) {
notify("success", "Auto Quest Saver", "Your quests have been saved.");
getQuests();
}
} catch {
} finally {
questSaverBusy = false;
}
}
async function refreshQuestCenter() {
if (!token || !userId) return;
const state = await fetchQuests(false);
if (state && pageId === "Quests") {
showQuests();
}
autoQuestSaver();
}
async function joinLeague() {
let wasPrivate = false;
try {
const pRes = await fetchApi(
"GET",
`https://www.duolingo.com/2023-05-23/users/${userId}/privacy-settings?fields=privacySettings`,
);
if (pRes.status === 200) {
const pData = safeJsonParse(pRes.responseText, {});
const soc = (pData.privacySettings || []).find(
(s) => s.id === "disable_social",
);
wasPrivate = soc ? soc.enabled : false;
}
} catch {}
if (wasPrivate) {
try {
await fetchApi(
"PATCH",
`https://www.duolingo.com/2023-05-23/users/${userId}/privacy-settings?fields=privacySettings`,
{ DISABLE_SOCIAL: false },
);
await wait(2000);
} catch {}
}
try {
const ok = await playStory(0);
if (ok && user) {
user.totalXp += 30;
showUser();
}
} catch {}
if (wasPrivate) {
try {
await fetchApi(
"PATCH",
`https://www.duolingo.com/2023-05-23/users/${userId}/privacy-settings?fields=privacySettings`,
{ DISABLE_SOCIAL: true },
);
} catch {}
}
}
async function farmLeague(targetRank) {
stopBtn("DX_League_Btn");
setProgress("DX_League", 10);
let joinAttemptCount = 0;
const sig = farmSignal("league");
try {
while (farmStates.league) {
try {
const res = await fetchApi(
"GET",
`${config.api.leaderboards}/users/${userId}?client_unlocked=true&get_reactions=true&_=${Date.now()}`,
null,
null,
sig,
);
if (!farmStates.league) break;
if (res.status !== 200) {
await waitStop(3000, sig);
continue;
}
const data = safeJsonParse(res.responseText, {});
leagueDataCache = data;
leagueDataTs = Date.now();
applyLeagueSummary(data);
const activeRanks = data?.active?.cohort?.rankings || [];
const cRankings = activeRanks.find((u) => u.user_id == userId);
if (!cRankings) {
if (joinAttemptCount === 0) {
joinAttemptCount = 1;
notify(
"info",
"Auto League",
"You are not in a league yet. Joining now...",
);
await joinLeague();
await waitStop(3000, sig);
continue;
} else if (joinAttemptCount < 10) {
joinAttemptCount++;
try {
const ok = await playStory(0, sig);
if (ok && user) {
user.totalXp += 30;
showUser();
}
} catch {}
await waitStop(3000, sig);
continue;
}
notify(
"error",
"League Error",
"Could not confirm league join status after 10 checks. Please try again later.",
);
break;
}
const cRankPos = activeRanks.indexOf(cRankings) + 1;
const tUserRanking = activeRanks[targetRank - 1];
if (!tUserRanking || cRankPos <= targetRank) {
if (farmStates.league) {
notify("success", "Goal Reached", `Reached Rank #${targetRank}!`);
}
setProgress("DX_League", 100);
break;
}
const scoreGap = tUserRanking.score - cRankings.score;
const progressPct = Math.min(
95,
Math.floor((cRankings.score / tUserRanking.score) * 100),
);
setProgress("DX_League", progressPct);
const room = parseInt(localStorage.getItem("dx_xp_room")) || 0;
const overshoot = room > 0 ? Math.min(500, Math.max(30, room)) : 5;
if (scoreGap + overshoot > 0) {
const bonus = Math.min(469, Math.max(0, scoreGap - 30 + overshoot));
const ok = await playStory(bonus, sig);
if (!farmStates.league) break;
if (ok) {
user.totalXp += 30 + bonus;
showUser();
} else {
await waitStop(2000, sig);
}
}
await waitStop(delayMs, sig);
} catch {
await waitStop(3000, sig);
}
}
const completed = farmStates.league;
if (!completed) {
notify("warning", "Auto League Stopped", "Rank targeting aborted.");
}
clearProgress("DX_League", completed);
refreshStats(true);
} finally {
farmStates.league = false;
farmCtl.league = null;
resetBtn("DX_League_Btn", "RUN");
}
}
function showConfirmModal(onConfirm) {
const modal = document.getElementById("DX_Confirm_Modal");
const btnCancel = document.getElementById("DX_Modal_Cancel");
const btnConfirm = document.getElementById("DX_Modal_Confirm");
const cleanup = () => {
modal.classList.remove("show");
btnCancel.removeEventListener("click", handleCancel);
btnConfirm.removeEventListener("click", handleConfirm);
};
const handleCancel = () => cleanup();
const handleConfirm = () => {
cleanup();
onConfirm();
};
btnCancel.addEventListener("click", handleCancel);
btnConfirm.addEventListener("click", handleConfirm);
modal.classList.add("show");
}
let leaguePollTimer = null;
let leagueJoinAttempted = false;
let leagueDataCache = null;
let leagueDataTs = 0;
const LEAGUE_TTL = 30000;
async function fetchLeagueData(force) {
if (!userId || !token) return null;
if (!force && leagueDataCache && Date.now() - leagueDataTs < LEAGUE_TTL) {
return leagueDataCache;
}
try {
const res = await fetchApi(
"GET",
`${config.api.leaderboards}/users/${userId}?client_unlocked=true&get_reactions=true&_=${Date.now()}`,
);
if (res.status === 200) {
const parsed = safeJsonParse(res.responseText);
if (parsed) {
leagueDataCache = parsed;
leagueDataTs = Date.now();
}
}
} catch {}
return leagueDataCache;
}
function leagueRankFromData(data) {
const active = data?.active;
if (active && active.cohort && Array.isArray(active.cohort.rankings)) {
const myIndex = active.cohort.rankings.findIndex(
(r) => r.user_id == userId,
);
return myIndex !== -1 ? myIndex + 1 : 0;
}
return null;
}
function applyLeagueSummary(data) {
const cohort = data?.active?.cohort;
const rankings = cohort?.rankings;
if (!Array.isArray(rankings)) return;
const idx = rankings.findIndex((r) => String(r.user_id) === String(userId));
const tier = cohort?.tier;
updateLeagueBadge(tier);
updateProfileLeague(tier, idx >= 0 ? idx + 1 : null);
}
async function getLeagueRank() {
return leagueRankFromData(await fetchLeagueData(true));
}
function updateLeagueDropdown(rank) {
const sel = document.getElementById("DX_League_Select");
if (!sel) return;
if (sel.classList.contains("open")) return;
const opts = sel.querySelector(".DX_Select_Options");
const text = sel.querySelector(".DX_Select_Text");
const chevron = sel.querySelector(".DX_Chevron");
const btn = document.getElementById("DX_League_Btn");
const lbl = document.getElementById("DX_League_Lbl");
if (btn && !farmStates.league) btn.disabled = false;
if (lbl && !farmStates.league) lbl.innerText = "RUN";
if (chevron) chevron.style.display = "";
sel.style.pointerEvents = "auto";
const maxPos = 15;
let optHtml = "";
for (let i = 1; i <= maxPos; i++) {
optHtml += `Login required.
`;
return;
}
const isRefresh = questState !== null;
const prevScroll = cont.scrollTop;
if (!isRefresh) {
cont.innerHTML = `Loading...
`;
}
const state = await fetchQuests(force);
if (state) {
showQuests();
cont.scrollTop = prevScroll;
if (forceBtn) {
forceBtn.disabled = false;
}
} else {
if (!isRefresh)
cont.innerHTML = `Failed to load quests.
`;
}
}
function questDisplayGoals() {
if (!questState || !Array.isArray(questState.schema?.goals)) {
return [];
}
const mGoalMap = new Map();
questState.schema.goals.forEach((goal) => {
if (!goal || !goal.goalId) return;
const match = goal.goalId.match(/^(\d{4}_\d{2})_monthly/);
if (!match) {
mGoalMap.set(goal.goalId, goal);
return;
}
const exGoal = mGoalMap.get(match[1]);
if (!exGoal) {
mGoalMap.set(match[1], goal);
} else if (
!exGoal.category?.includes("CHALLENGE") &&
goal.category?.includes("CHALLENGE")
) {
mGoalMap.set(match[1], goal);
}
});
return [...mGoalMap.values()].reverse();
}
function questRemaining(goal) {
const isEarned =
questState.earned.has(goal.badgeId) || questState.earned.has(goal.goalId);
if (isEarned) return 0;
const rData = questState.progress[goal.goalId];
let cVal = 0;
if (typeof rData === "number") cVal = rData;
else if (rData && rData.progress) cVal = rData.progress;
return Math.max(0, (goal.threshold || 10) - cVal);
}
function showQuests(filterStr) {
const cont = document.getElementById("DX_Quest_Container");
if (!cont) {
return;
}
const searchEl = document.getElementById("DX_Quest_Search");
const query = (
filterStr !== undefined ? filterStr : searchEl ? searchEl.value : ""
)
.trim()
.toLowerCase();
cont.innerHTML = "";
const allGoals = questDisplayGoals();
if (allGoals.length === 0) {
cont.innerHTML = `No active quests.
`;
return;
}
const yearOf = (goal) => {
const m = goal.goalId.match(/^(\d{4})_/);
return m ? m[1] : "Daily";
};
const ddGoals = (
query
? allGoals.filter((goal) =>
(goal.title?.uiString || goal.goalId || "")
.toLowerCase()
.includes(query),
)
: allGoals
).filter((goal) => yearOf(goal) !== "Daily");
if (ddGoals.length === 0) {
cont.innerHTML = `No quests found.
`;
return;
}
const sorted = ddGoals.slice().sort((a, b) => {
const ya = yearOf(a),
yb = yearOf(b);
if (ya === yb) return 0;
if (ya === "Daily") return -1;
if (yb === "Daily") return 1;
return Number(yb) - Number(ya);
});
let lastYear = null;
sorted.forEach((goal) => {
const yr = yearOf(goal);
if (yr !== lastYear) {
lastYear = yr;
const yHeader = document.createElement("div");
yHeader.className = "DX_Shop_Section_Header DX_NoSel";
yHeader.innerHTML = `Failed to load shop. Please try again.
`;
}
} catch {
cont.innerHTML = `Failed to load shop. Please try again.
`;
}
}
function showShop(filterStr) {
const cont = document.getElementById("DX_Shop_Container");
if (!cont) return;
cont.innerHTML = "";
const query = (filterStr || "").trim().toLowerCase();
const fPowerUps = query
? powerUpItems.filter((p) => p.name.toLowerCase().includes(query))
: powerUpItems;
const fItems = query
? shopCache.filter((i) =>
((i.displayName || "") + (i.id || "")).toLowerCase().includes(query),
)
: shopCache;
if (fPowerUps.length === 0 && fItems.length === 0) {
cont.innerHTML = `No items found.
`;
return;
}
const grid = document.createElement("div");
grid.className = "DX_Shop_Grid";
const fragment = document.createDocumentFragment();
if (fPowerUps.length > 0) {
const puHeader = document.createElement("div");
puHeader.className = "DX_Shop_Section_Header DX_NoSel";
puHeader.innerHTML = `
Loading...
`;
try {
const data = preData || (await fetchLeagueData(false));
const cohort = data?.active?.cohort;
const contest = data?.active?.contest;
const rankings = cohort?.rankings;
if (!Array.isArray(rankings) || rankings.length === 0) {
if (!loaded)
cont.innerHTML = `You are not in an active league.
`;
return;
}
const tier = cohort?.tier;
updateLeagueBadge(tier);
const nProm = (contest?.ruleset?.num_promoted || [])[tier] || 0;
const nDem = (contest?.ruleset?.num_demoted || [])[tier] || 0;
const total = rankings.length;
const statusMap = {};
statusReactions.forEach((s) => {
statusMap[s.value] = s;
});
const frag = document.createDocumentFragment();
const setIco = DUO_LEAGUES_CDN + "6df6337370e45c1b9a5029e78211d114.svg";
let myStatus = null;
let myRank = null;
rankings.forEach((r, i) => {
const rank = i + 1;
const isMe = String(r.user_id) === String(userId);
const av = r.avatar_url
? (r.avatar_url.startsWith("http")
? r.avatar_url
: "https:" + r.avatar_url) + "/xlarge"
: "";
const st =
r.reaction && r.reaction !== "NONE" ? statusMap[r.reaction] : null;
if (isMe) {
myStatus = st;
myRank = rank;
}
let statusHtml;
if (isMe) {
const inner = st
? renderStatusIcon(st, 12)
: `Failed to load leaderboard.
`;
}
}
async function removeHearts(count) {
const btn = document.getElementById("DX_Hearts_Btn");
if (btn) btn.disabled = true;
let ok = 0;
for (let i = 0; i < count; i++) {
try {
const res = await fetchApi(
"PUT",
`${config.api.users}/${userId}/remove-heart`,
);
if (res.status === 200) ok++;
} catch {}
setProgress("DX_Hearts", ((i + 1) / count) * 100);
await wait(delayMs);
}
notify(
ok > 0 ? "success" : "error",
"Remove Hearts",
ok > 0 ? `Removed ${ok} heart(s).` : "Failed to remove hearts.",
);
clearProgress("DX_Hearts", ok > 0);
if (btn) btn.disabled = false;
}
function applyLocalMax() {
if (localStorage.getItem("dx_local_max") !== "true") return;
if (document.getElementById("DX_LocalMax_Script")) return;
const script = document.createElement("script");
script.id = "DX_LocalMax_Script";
script.textContent = `
(function() {
const TARGET_URL_REGEX = /https?:\\/\\/(?:[a-zA-Z0-9-]+\\.)?duolingo\\.[a-zA-Z]{2,6}(?:\\.[a-zA-Z]{2})?\\/\\d{4}-\\d{2}-\\d{2}\\/users\\/.+/;
const CUSTOM_SHOP_ITEMS = {
gold_subscription: {
itemName: "gold_subscription",
subscriptionInfo: {
vendor: "STRIPE",
renewing: true,
expectedExpiration: Date.now() + 31536000000
}
}
};
const originalFetch = window.fetch;
window.fetch = function (resource, options) {
const url = resource instanceof Request ? resource.url : resource;
if (TARGET_URL_REGEX.test(url)) {
return originalFetch.apply(this, arguments).then(async function (response) {
const resp = response.clone();
let raw = await resp.text();
try {
let data = JSON.parse(raw);
data.hasPlus = true;
if (!data.trackingProperties || typeof data.trackingProperties !== 'object') data.trackingProperties = {};
data.trackingProperties.has_item_gold_subscription = true;
data.shopItems = CUSTOM_SHOP_ITEMS;
raw = JSON.stringify(data);
} catch { }
let hdrs = response.headers;
try { const obj = {}; response.headers.forEach((v, k) => obj[k] = v); hdrs = obj; } catch { }
return new Response(raw, { status: response.status, statusText: response.statusText, headers: hdrs });
});
}
return originalFetch.apply(this, arguments);
};
const origOpen = XMLHttpRequest.prototype.open;
const origSend = XMLHttpRequest.prototype.send;
XMLHttpRequest.prototype.open = function (method, url, ...args) {
this._intercept = TARGET_URL_REGEX.test(url);
this._url = url;
origOpen.call(this, method, url, ...args);
};
XMLHttpRequest.prototype.send = function () {
if (this._intercept) {
const origChange = this.onreadystatechange;
const xhr = this;
this.onreadystatechange = function () {
if (xhr.readyState === 4 && xhr.status >= 200 && xhr.status < 300) {
try {
let raw = xhr.responseText;
try {
let data = JSON.parse(raw);
data.hasPlus = true;
if (!data.trackingProperties || typeof data.trackingProperties !== 'object') data.trackingProperties = {};
data.trackingProperties.has_item_gold_subscription = true;
data.shopItems = CUSTOM_SHOP_ITEMS;
raw = JSON.stringify(data);
} catch { }
Object.defineProperty(xhr, 'responseText', { writable: true, value: raw });
Object.defineProperty(xhr, 'response', { writable: true, value: raw });
} catch { }
}
if (origChange) origChange.apply(this, arguments);
};
}
origSend.apply(this, arguments);
};
function remove(root = document) {
const sections = root.querySelectorAll('section._3f-te');
for (let i = 0; i < sections.length; i++) {
const h2 = sections[i].querySelector('h2._203-l');
if (h2 && h2.textContent.trim() === 'Manage subscription') {
sections[i].remove();
break;
}
}
}
const observer = new MutationObserver(function () {
remove();
});
observer.observe(document.documentElement, { childList: true, subtree: true });
remove();
})();
`;
document.documentElement.appendChild(script);
}
async function getCohort() {
return (await fetchLeagueData(false))?.active?.cohort?.cohort_id || null;
}
async function getCurrentStatus() {
const rankings =
(await fetchLeagueData(true))?.active?.cohort?.rankings || [];
const me = rankings.find((r) => r.user_id == userId);
return me ? me.reaction || "NONE" : null;
}
async function setStatus(reaction) {
if (!userId) return false;
const cohort = await getCohort();
if (!cohort) {
notify("error", "Leaderboard Status", "You are not in an active league.");
return false;
}
try {
const res = await fetchApi(
"PATCH",
`https://duolingo-leaderboards-prod.duolingo.com/reactions/${cohort}/users/${userId}`,
{ reaction: reaction },
);
if (res.status === 200) {
notify("success", "Leaderboard Status", "Status successfully updated.");
const me = leagueDataCache?.active?.cohort?.rankings?.find(
(r) => String(r.user_id) === String(userId),
);
if (me) me.reaction = reaction;
leagueDataTs = 0;
return true;
}
notify(
"error",
"Leaderboard Status",
`Failed to update status (Status ${res.status}).`,
);
return false;
} catch {
notify("error", "Leaderboard Status", "Network error: Request failed.");
return false;
}
}
function renderStatusIcon(st, size = 12) {
if (!st) return "";
if (st.icon) {
if (st.icon.startsWith("
',
info: '
',
error:
'
',
warning:
'
',
chevron:
'',
hideBtn:
'',
showBtn:
'',
discordBtn:
'',
githubBtn:
'',
webBtn:
'',
modeNative:
'
',
modeSolver:
'
