Wikipedia

User:Daniel Quinlan/Scripts/RangeHelper.js: Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
improve partial block support
improve user talk page fetching by using Special:PrefixIndex
 
(16 intermediate revisions by the same user not shown)
Line 1:
class IPAddress {
static from(input) {
if (typeof input !== 'string') return null;
try {
const parsed = IPAddress.#parse(input);
return parsed ? new IPAddress(parsed) : null;
} catch {
return null;
}
}
 
constructor({ version, ip, mask }) {
this.version = version;
this.ip = ip;
this.mask = mask;
this.effectiveMask = mask ?? (version === 4 ? 32 : 128);
}
 
equals(other) {
return other instanceof IPAddress &&
this.version === other.version &&
this.ip === other.ip &&
this.effectiveMask === other.effectiveMask;
}
 
masked(prefixLength) {
const size = this.version === 4 ? 32 : 128;
const mask = (1n << BigInt(size - prefixLength)) - 1n;
const maskedIP = this.ip & ~mask;
return new IPAddress({
ip: maskedIP,
mask: prefixLength,
version: this.version
});
}
 
enumerate() {
if (this.version != 4) {
throw new Error('can only enumerate IPv4 addresses');
}
const count = 1n << BigInt(32 - this.mask);
let current = this.masked(this.mask).ip;
return Array.from({ length: Number(count) }, () =>
IPAddress.#bigIntToIPv4(current++)
);
}
 
toString(uppercase = true, compress = false) {
let ipString = this.version === 4
? IPAddress.#bigIntToIPv4(this.ip)
: IPAddress.#bigIntToIPv6(this.ip);
if (compress && this.version === 6) {
ipString = IPAddress.#compressIPv6(ipString);
}
if (this.mask !== null) {
ipString += `/${this.mask}`;
}
return uppercase ? ipString.toUpperCase() : ipString;
}
 
getRange() {
const size = this.version === 4 ? 32 : 128;
const effectiveMask = this.effectiveMask;
const hostBits = BigInt(size - effectiveMask);
const start = this.ip & (~0n << hostBits);
const end = start | ((1n << hostBits) - 1n);
return {
start: new IPAddress({ ip: start, mask: null, version: this.version }),
end: new IPAddress({ ip: end, mask: null, version: this.version })
};
}
 
inRange(other) {
if (!(other instanceof IPAddress)) return false;
if (this.version !== other.version) return false;
const { start, end } = this.getRange();
return other.ip >= start.ip && other.ip <= end.ip;
}
 
static #parse(input) {
const IPV4REGEX = /^((?:1?\d\d?|2[0-2]\d)\b(?:\.(?:1?\d\d?|2[0-4]\d|25[0-5])){3})(?:\/(1[6-9]|2\d|3[0-2]))?$/;
const IPV6REGEX = /^((?:[\dA-Fa-f]{1,4}:){7}[\dA-Fa-f]{1,4}|(?:[\dA-Fa-f]{1,4}:){1,7}:|(?:[\dA-Fa-f]{1,4}:){1,6}:[\dA-Fa-f]{1,4}|(?:[\dA-Fa-f]{1,4}:){1,5}(?:\:[\dA-Fa-f]{1,4}){1,2}|(?:[\dA-Fa-f]{1,4}:){1,4}(?:\:[\dA-Fa-f]{1,4}){1,3}|(?:[\dA-Fa-f]{1,4}:){1,3}(?:\:[\dA-Fa-f]{1,4}){1,4}|(?:[\dA-Fa-f]{1,4}:){1,2}(?:\:[\dA-Fa-f]{1,4}){1,5}|[\dA-Fa-f]{1,4}:(?:(?:\:[\dA-Fa-f]{1,4}){1,6}))(?:\/(19|[2-9]\d|1[01]\d|12[0-8]))?$/; // based on https://stackoverflow.com/a/17871737
const match = IPV4REGEX.exec(input) || IPV6REGEX.exec(input);
if (match) {
const version = match[1].includes(':') ? 6 : 4;
const ip = version === 4 ? IPAddress.#ipv4ToBigInt(match[1]) : IPAddress.#ipv6ToBigInt(match[1]);
const mask = match[2] ? parseInt(match[2], 10) : null;
return { version, ip, mask };
}
return null;
}
 
static #ipv4ToBigInt(ipv4) {
const octets = ipv4.split('.').map(BigInt);
return (octets[0] << 24n) | (octets[1] << 16n) | (octets[2] << 8n) | octets[3];
}
 
static #expandIPv6(segments) {
const expanded = [];
let hasEmpty = false;
segments.forEach(segment => {
if (segment === '' && !hasEmpty) {
expanded.push(...Array(8 - segments.filter(s => s).length).fill('0'));
hasEmpty = true;
} else if (segment === '') {
expanded.push('0');
} else {
expanded.push(segment);
}
});
return expanded.map(seg => seg.padStart(4, '0'));
}
 
static #ipv6ToBigInt(ipv6) {
const segments = ipv6.split(':');
let bigIntValue = 0n;
const expanded = IPAddress.#expandIPv6(segments);
expanded.forEach(segment => {
bigIntValue = (bigIntValue << 16n) + BigInt(parseInt(segment, 16));
});
return bigIntValue;
}
 
static #bigIntToIPv4(bigIntValue) {
return [
(bigIntValue >> 24n) & 255n,
(bigIntValue >> 16n) & 255n,
(bigIntValue >> 8n) & 255n,
bigIntValue & 255n,
].join('.');
}
 
static #bigIntToIPv6(bigIntValue) {
const segments = [];
for (let i = 0; i < 8; i++) {
const segment = (bigIntValue >> BigInt((7 - i) * 16)) & 0xffffn;
segments.push(segment.toString(16));
}
return segments.join(':')
}
 
static #compressIPv6(ipv6) {
let run = null;
for (const match of ipv6.matchAll(/:?\b(0(?:\:0)+)\b:?/g)) {
if (!run || match[1].length > run[1].length) {
run = match;
}
}
return run ? `${ipv6.slice(0, run.index)}::${ipv6.slice(run.index + run[0].length)}` : ipv6;
}
}
 
mw.loader.using(['mediawiki.api', 'mediawiki.util', 'mediawiki.DateFormatter']).then(function() {
// state variables
Line 5 ⟶ 157:
let formatTimeAndDate = null;
 
// special page handling
// activate on relevant special pages
const pageName = mw.config.get('wgPageName');
const specialPage = mw.config.get('wgCanonicalSpecialPageName');
Line 11 ⟶ 163:
const userToolsBDI = document.querySelector('.mw-contributions-user-tools bdi');
const userName = userToolsBDI ? userToolsBDI.textContent.trim() : '';
const ip = extractIPIPAddress.from(userName);
if (ip) {
addContributionsLinks(ip);
if (ip.mask !== (ip.version === 6 ? 128 : 32)) {
mw.util.addPortletLink('p-tb', '/wiki/Special:BlankPage/RangeCalculator', 'Range calculator');
mw.util.addPortletLink('p-tb', '#', 'Range selector')
.addEventListener('click', event => {
event.preventDefault();
startRangeSelection();
});
}
}
} else if (specialPage === 'Blankpage') {
const match = pageName.match(/^Special:BlankPage\/(\w+)(?:\/(.+))?$/);
if (!match) {return;
if (match[1] === 'RangeBlocks') {
const ip = extractIPIPAddress.from(match[2] || '');
if (ip) {
displayRangeBlocks(ip);
}
} else if (match[1] === 'RangeCalculator') {
displayRangeCalculator();
}
} else if (match[1] === 'RangeCalculator') {
displayRangeCalculator();
}
} else if (mw.config.get('wgCanonicalNamespace') === 'User_talk') {
const ip = IPAddress.from(mw.config.get('wgTitle'));
if (ip && ip.mask) {
displayRangeTalk(ip);
}
} else if (pageName === 'Special:Log/block') {
Line 39 ⟶ 187:
if (pageParam) {
const match = pageParam.match(/^User:(.+)$/);
if (!match) {return;
const ip = extractIPIPAddress.from(match[1]);
if (ip) {
mw.util.addPortletLink('p-tb', `/wiki/Special:BlankPage/RangeBlocks/${ip.ip}`, "Find range blocks");
}
}
}
Line 53 ⟶ 200:
const userToolsContainer = document.querySelector('.mw-contributions-user-tools .mw-changeslist-links');
if (!userToolsContainer) return;
const existingTalkLink = userToolsContainer.querySelector('.mw-contributions-link-talk');
const rangeTalkLink = document.createElement('a');
rangeTalkLink.className = 'mw-contributions-link-talk-range';
const wrapper = document.createElement('span');
if (existingTalkLink) {
const mask = ip.version === 4 ? 24 : 64;
const range = ip.masked(mask);
rangeTalkLink.href = `/wiki/User_talk:${range}`;
rangeTalkLink.title = `User talk:${range}`;
rangeTalkLink.textContent = `(/${mask})`;
wrapper.appendChild(document.createTextNode(' '));
wrapper.appendChild(rangeTalkLink);
existingTalkLink.parentNode.insertBefore(wrapper, existingTalkLink.nextSibling);
} else {
rangeTalkLink.href = `/wiki/User_talk:${ip}`;
rangeTalkLink.title = `User talk:${ip}`;
rangeTalkLink.textContent = 'talk';
wrapper.appendChild(rangeTalkLink);
userToolsContainer.insertBefore(wrapper, userToolsContainer.firstChild);
}
const blockLogLink = userToolsContainer.querySelector('.mw-contributions-link-block-log');
if (blockLogLink) {
const rangeLogLink = document.createElement('a');
const rangeLogPage = `Special:BlankPage/RangeBlocks/${ip}`;
rangeLogLink.href = `/wiki/${rangeLogPage}`;
rangeLogLink.textContent = '(ranges)';
rangeLogLink.className = 'mw-link-range-blocks';
rangeLogLink.title = rangeLogPage;
const wrapperSpan = document.createElement('span');
wrapperSpan.appendChild(document.createTextNode(' '));
wrapperSpan.appendChild(rangeLogLink);
blockLogLink.parentNode.insertBefore(wrapperSpan, blockLogLink.nextSibling);
}
const spans = userToolsContainer.querySelectorAll('span');
let insertBefore = null;
Line 62 ⟶ 242:
}
if (!insertBefore) return;
letconst floor = 16, ceilingip.version === 24,4 steps? =16 : 832;
ifconst ceiling = Math.min(ip.version === 6)4 {? 24 : 64, ip.effectiveMask - 1);
const steps = ip.effectiveMask >= 64 ? 16 : 8;
floor = 32;
for (let mask = floor; mask <= ceiling; mask += steps) {
ceiling = 64;
if (ip.mask >= 64)
steps = 16;
}
let links = [];
const rangeBlockLink = document.createElement('a');
rangeBlockLink.href = `/wiki/Special:BlankPage/RangeBlocks/${ip.ip}`;
rangeBlockLink.textContent = 'range block log';
rangeBlockLink.className = 'mw-link-range-blocks';
links.push(rangeBlockLink);
for (let mask = floor; mask <= ceiling && mask < ip.mask; mask += steps) {
const contribsLink = document.createElement('a');
contribsLink.href = `/wiki/Special:Contributions/${ip.ip}/${masked(mask)}`;
contribsLink.textContent = `/${mask}`;
contribsLink.className = 'mw-contributions-link-range-suggestion';
links.push(contribsLink)
}
links.forEach(link => {
const span = document.createElement('span');
span.appendChild(linkcontribsLink);
userToolsContainer.insertBefore(span, insertBefore);
});
if (ip.mask) {
mw.util.addPortletLink('p-tb', '/wiki/Special:BlankPage/RangeCalculator', 'Range calculator');
mw.util.addPortletLink('p-tb', '#', 'Range selector')
.addEventListener('click', event => {
event.preventDefault();
startRangeSelection();
});
}
}
 
// find range blocks
// generate styled div for IP range calculation results
async function createRangeDisplaydisplayRangeBlocks(ip) {
api = new mw.Api();
const display = document.createElement('div');
formatTimeAndDate = mw.loader.require('mediawiki.DateFormatter').formatTimeAndDate;
display.id = 'range-display';
document.title = `Range blocks for ${ip}`;
display.style.fontWeight = 'bold';
const heading = document.querySelector('#firstHeading');
display.style.border = '1px solid var(--border-color-base, #a2a9b1)';
if (heading) {
display.style.borderRadius = '2px';
heading.textContent = `Range blocks for ${ip}`;
display.style.padding = '16px';
}
display.style.fontSize = '1rem';
const contentContainer = document.querySelector('#mw-content-text');
display.style.margin = '1em 0';
if (!contentContainer) return;
return display;
contentContainer.innerHTML = '';
const statusMessage = document.createElement('p');
statusMessage.innerHTML = `Querying logs for IP blocks affecting <a href="/wiki/Special:Contributions/${ip}">${ip}</a>...`;
contentContainer.appendChild(statusMessage);
const resultsList = document.createElement('ul');
contentContainer.appendChild(resultsList);
const masks = ip.version === 4 ? sequence(16, 31) : sequence(19, 64);
const ranges = masks.map(mask => ip.masked(mask));
if (!masks.includes(ip.mask)) {
ranges.push(ip);
}
const blocks = [];
const blockPromises = ranges.map(range => {
return getBlockLogs(api, range).then(async (blockLogs) => {
for (const block of blockLogs) {
const formattedBlock = await formatBlockEntry(block);
blocks.push({ logid: block.logid, formattedBlock });
}
}).catch(error => {
console.error(`Error fetching block logs for range ${range}:`, error);
});
});
await Promise.all(blockPromises);
blocks.sort((a, b) => b.logid - a.logid);
blocks.forEach(({ formattedBlock }) => {
const li = document.createElement('li');
li.innerHTML = formattedBlock;
resultsList.appendChild(li);
});
if (!blocks.length) {
statusMessage.innerHTML = '<span style="color:red;">No blocks found.</span>';
} else {
statusMessage.innerHTML = `Range blocks for <a href="/wiki/Special:Contributions/${ip}">${ip}</a>`;
}
mw.hook('wikipage.content').fire($(contentContainer));
}
 
// computedisplay commontalk IP rangepages for IP listrange
async function computeCommonRangedisplayRangeTalk(ipsip) {
async function getUserTalkPages(ip, maxPages = 32) {
if (!ips.length) {
const userTalk = new Set();
return '<span style="color:red;">No valid IPs found.</span>';
const { start, end } = ip.getRange();
const prefix = commonPrefix(start.toString(true), end.toString(true));
const validPrefix = /^\w+[.:]\w+[.:]/.test(prefix);
let url = null;
let pagesFetched = 0;
let errors = false;
if (validPrefix) {
url = `/wiki/Special:PrefixIndex?prefix=${encodeURIComponent(prefix)}&namespace=3`;
}
while (url && pagesFetched < maxPages && !errors) {
try {
const html = await fetch(url).then(res => res.text());
const parser = new DOMParser();
const fetched = parser.parseFromString(html, 'text/html');
const links = fetched.querySelectorAll('ul.mw-prefixindex-list > li > a');
for (const link of links) {
const ipText = link.textContent;
const pageIp = IPAddress.from(ipText);
if (pageIp && ip.inRange(pageIp)) {
userTalk.add(`User talk:${ipText}`);
}
}
const nextLink = fetched.querySelector('.mw-prefixindex-nav a');
if (nextLink && nextLink.textContent.includes('Next page') && nextLink.href) {
url = nextLink.href;
} else {
url = null;
}
} catch (error) {
console.error('Error fetching usertalk pages:', error);
errors = true;
break;
}
pagesFetched++;
}
if (!validPrefix || errors || pagesFetched === maxPages) {
url = `/wiki/Special:Contributions/${ip}?limit=500`;
try {
const html = await fetch(url).then(res => res.text());
const parser = new DOMParser();
const fetched = parser.parseFromString(html, 'text/html');
const talkLinks = fetched.querySelectorAll('.mw-contributions-list a.mw-usertoollinks-talk:not(.new)');
for (const link of talkLinks) {
const title = link.title;
if (title) userTalk.add(title);
}
} catch (error) {
console.error('Error fetching usertalk pages:', error);
}
}
return Array.from(userTalk);
}
function timeAgo(timestamp) {
const firstVersion = ips[0].version;
const delta = (Date.now() - new Date(timestamp)) / 1000;
if (!ips.every(ip => ip.version === firstVersion)) {
const units = { year: 31536000, month: 2628000, day: 86400, hour: 3600, minute: 60 };
return '<span style="color:red;">Mixed IPv4 and IPv6 addresses are not supported.</span>';
for (const [unit, seconds] of Object.entries(units)) {
let count = delta / seconds;
if (count >= 1) return `${count | 0} ${unit}${count >= 2 ? 's' : ''}`;
}
return 'just now';
}
api = new mw.Api();
const masks = firstVersion === 6 ? sequence(19, 64) : sequence(16, 32);
const contentContainer = document.querySelector('#mw-content-text');
const bestMask = masks.findLast(m => {
if (!contentContainer) return;
const base = maskedIP(ips[0], m);
const elementsToRemove = [
return ips.every(ip => maskedIP(ip, m) === base);
'#mw-content-subtitle .subpages',
});
'#mw-content-text .noarticletext',
if (!bestMask) {
'.vector-menu-content-list #ca-addsection',
return '<span style="color:red;">No common range found.</span>';
'.vector-menu-content-list #ca-dt-page-subscribe',
'.vector-menu-content-list #ca-edit',
'.vector-menu-content-list #ca-nstab-user',
'.vector-menu-content-list #ca-protect',
'.vector-menu-content-list #ca-talk',
'.vector-menu-content-list #ca-watch',
'.vector-menu-content-list #ca-wikilove',
'.vector-menu-content-list #t-info',
'.vector-menu-content-list #t-log',
'.vector-menu-content-list #t-urlshortener',
'.vector-menu-content-list #t-urlshortener-qrcode',
'.vector-menu-content-list #t-whatlinkshere',
];
for (const selector of elementsToRemove) {
document.querySelector(selector)?.remove();
}
const cactions = document.getElementById('p-cactions');
if (cactions) {
const listItems = cactions.querySelectorAll('li');
const anyVisible = Array.from(listItems).some(li => {
return li.offsetParent !== null;
});
if (!anyVisible) {
cactions.style.display = 'none';
}
}
const contributions = document.querySelector('#t-contributions a');
if (contributions) {
contributions.href = `/wiki/Special:Contributions/${ip}`;
}
const globalContributions = document.querySelector('#t-global-contributions a');
if (globalContributions) {
globalContributions.href = `/wiki/Special:GlobalContributions/${ip}`;
}
const blockUser = document.querySelector('#t-blockip a');
if (blockUser) {
blockUser.href = `/wiki/Special:Block/${ip}`;
}
let userTalk;
let userTalkMethod;
if (ip.version === 4 && ip.mask >= 24) {
userTalk = ip.enumerate().map(ipString => `User talk:${ipString}`);
userTalkMethod = "enumerate";
} else {
userTalk = await getUserTalkPages(ip);
userTalkMethod = "contributions";
if (!userTalk.length) {
const resultMessage = document.createElement('p');
resultMessage.style.color = 'var(--color-notice, gray)';
resultMessage.textContent = 'No user talk pages found for recent contributions from this IP range.';
contentContainer.appendChild(resultMessage);
return;
}
}
const infoResponses = await Promise.all(
batch(userTalk, 50).map(titles => api.get({
action: 'query',
titles: titles.join('|'),
prop: 'info|revisions',
format: 'json',
formatversion: 2
}))
);
const pages = infoResponses
.flatMap(response => response.query.pages)
.filter(page => !page.missing && page.revisions && page.revisions.length > 0)
.map(page => ({
title: page.title,
timestamp: page.revisions[0].timestamp,
redirect: !!page.redirect
}))
.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
if (!pages.length) {
const resultMessage = document.createElement('p');
if (userTalkMethod === "enumerate") {
resultMessage.style.color = 'var(--color-notice, gray)';
resultMessage.textContent = 'No user talk pages found.';
} else {
resultMessage.style.color = 'var(--color-error, red)';
resultMessage.textContent = 'An error occurred while retrieving timestamps for user talk pages in this IP range.';
}
contentContainer.appendChild(resultMessage);
return;
}
const parseTasks = [];
for (const page of pages) {
const ip = page.title.replace(/^User talk:/, '');
const relativeTime = `${timeAgo(page.timestamp)} ago`;
const headerText = `== ${relativeTime}: [[Special:Contributions/${ip}|${ip}]] ([[${page.title}|talk]]) ==`;
const inclusionText = `{{${page.title}}}`;
parseTasks.push({ text: headerText, disableeditsection: true, });
parseTasks.push({ text: inclusionText, disableeditsection: false, });
}
const parsePromises = parseTasks.map(task =>
api.post({
action: 'parse',
format: 'json',
prop: 'text',
contentmodel: 'wikitext',
title: `Special:BlankPage/RangeTalk/${ip}`,
text: task.text,
disableeditsection: task.disableeditsection,
})
);
for (const promise of parsePromises) {
const result = await promise;
const html = result.parse.text['*'];
const fragment = document.createRange().createContextualFragment(html);
contentContainer.appendChild(fragment);
}
mw.hook('wikipage.content').fire($(contentContainer));
const twinkleElementsToRemove = [
'.vector-menu-content-list #tw-block',
'.vector-menu-content-list #tw-rpp',
'.vector-menu-content-list #tw-unlink',
'.vector-menu-content-list #tw-warn',
'.vector-menu-content-list #twinkle-talkback',
'.vector-menu-content-list #twinkle-welcome',
];
for (const selector of twinkleElementsToRemove) {
document.querySelector(selector)?.remove();
}
const resultRange = maskedIP(ips[0], bestMask);
const contribsLink = `<a href="/wiki/Special:Contributions/${resultRange}" target="_blank">${resultRange}</a>`;
const blockLink = `<a href="/wiki/Special:Block/${resultRange}" target="_blank">block</a>`;
return `<span>${ips.length} unique IP${ips.length === 1 ? '' : 's'}: ${contribsLink} (${blockLink})</span>`;
}
 
Line 130 ⟶ 513:
const heading = document.querySelector('#firstHeading');
if (heading) {
heading.innerHTMLtextContent = 'Range calculator';
}
const contentContainer = document.querySelector('#mw-content-text');
Line 156 ⟶ 539:
const input = document.getElementById('range-input').value;
const ipRegex = /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b|\b(?:[\dA-Fa-f]{1,4}:){4,}[\dA-Fa-f:]+/g;
const matches = [...input.matchAll(ipRegex)].map(m => m[0]);
const ips = [];
input.matchAll(ipRegex)
for (const match of matches) {
const ip.map(match => extractIPIPAddress.from(match[0]));
if .filter(ipBoolean) {
.forEach(ip => ipListAdd(ips, ip));
}
}
results.innerHTML = computeCommonRange(ips);
});
Line 188 ⟶ 568:
checkbox.addEventListener('change', () => {
const ipText = link.textContent.trim();
const ip = extractIPIPAddress.from(ipText);
if (!ip) return;
if (checkbox.checked) {
Line 201 ⟶ 581:
}
 
// generate styled div for IP range calculation results
// find range blocks
async function displayRangeBlockscreateRangeDisplay(ip) {
const display = document.createElement('div');
api = new mw.Api();
display.id = 'range-display';
formatTimeAndDate = mw.loader.require('mediawiki.DateFormatter').formatTimeAndDate;
display.style.fontWeight = 'bold';
document.title = `Range blocks for ${ip.ip}`;
display.style.border = '1px solid var(--border-color-base, #a2a9b1)';
const heading = document.querySelector('#firstHeading');
display.style.borderRadius = '2px';
if (heading) {
display.style.padding = '16px';
heading.innerHTML = `Range blocks for <a href="/wiki/Special:Contributions/${ip.ip}">${ip.ip}</a>`;
display.style.fontSize = '1rem';
display.style.margin = '1em 0';
return display;
}
 
// compute common IP range for IP list
function computeCommonRange(ips) {
if (!ips.length) {
return '<span style="color:red;">No valid IPs found.</span>';
}
const firstVersion = ips[0].version;
const contentContainer = document.querySelector('#mw-content-text');
if (!ips.every(ip => ip.version === firstVersion)) {
if (!contentContainer) return;
return '<span style="color:red;">Mixed IPv4 and IPv6 addresses are not supported.</span>';
contentContainer.innerHTML = '';
}
const statusMessage = document.createElement('p');
const masks = firstVersion === 4 ? sequence(16, 32) : sequence(19, 64);
statusMessage.innerHTML = `Querying logs for IP blocks affecting <a href="/wiki/Special:Contributions/${ip.ip}">${ip.ip}</a>...`;
const bestMask = masks.findLast(m => {
contentContainer.appendChild(statusMessage);
const resultsListbase = documentips[0].createElementmasked('ul'm);
return ips.every(ip => ip.masked(m).equals(base));
contentContainer.appendChild(resultsList);
const masks = ip.version === 6 ? sequence(19, 64) : sequence(16, 31);
const blocks = [];
const blockPromises = masks.map(mask => {
const range = maskedIP(ip, mask);
return getBlockLogs(api, range).then(async (blockLogs) => {
for (const block of blockLogs) {
const formattedBlock = await formatBlockEntry(block);
blocks.push({ logid: block.logid, formattedBlock });
}
}).catch(error => {
console.error(`Error fetching block logs for range ${range}:`, error);
});
});
if (!bestMask) {
await Promise.all(blockPromises);
return '<span style="color:red;">No common range found.</span>';
blocks.sort((a, b) => b.logid - a.logid);
blocks.forEach(({ formattedBlock }) => {
const li = document.createElement('li');
li.innerHTML = formattedBlock;
resultsList.appendChild(li);
});
if (!blocks.length) {
statusMessage.innerHTML = '<span style="color:red;">No blocks found.</span>';
} else {
statusMessage.innerHTML = `Range blocks for <a href="/wiki/Special:Contributions/${ip.ip}">${ip.ip}</a>`;
}
const resultRange = ips[0].masked(bestMask);
mw.hook('wikipage.content').fire($(contentContainer));
const contribsLink = `<a href="/wiki/Special:Contributions/${resultRange}" target="_blank">${resultRange.toString(false, true)}</a>`;
const blockLink = `<a href="/wiki/Special:Block/${resultRange}" target="_blank">block</a>`;
return `<span>${ips.length} unique IP${ips.length === 1 ? '' : 's'}: ${contribsLink} (${blockLink})</span>`;
}
 
Line 263 ⟶ 634:
params: event.params || {},
url: mw.util.getUrl('Special:Log', { logid: event.logid }),
range: range,
}));
}
 
// extract IP address
function extractIP(userName) {
const IPV4REGEX = /^((?:1?\d\d?|2[0-2]\d)\b(?:\.(?:1?\d\d?|2[0-4]\d|25[0-5])){3})(?:\/(1[6-9]|2\d|3[0-2]))?$/;
const IPV6REGEX = /^((?:[\dA-Fa-f]{1,4}:){7}[\dA-Fa-f]{1,4}|(?:[\dA-Fa-f]{1,4}:){1,7}:|(?:[\dA-Fa-f]{1,4}:){1,6}:[\dA-Fa-f]{1,4}|(?:[\dA-Fa-f]{1,4}:){1,5}(?:\:[\dA-Fa-f]{1,4}){1,2}|(?:[\dA-Fa-f]{1,4}:){1,4}(?:\:[\dA-Fa-f]{1,4}){1,3}|(?:[\dA-Fa-f]{1,4}:){1,3}(?:\:[\dA-Fa-f]{1,4}){1,4}|(?:[\dA-Fa-f]{1,4}:){1,2}(?:\:[\dA-Fa-f]{1,4}){1,5}|[\dA-Fa-f]{1,4}:(?:(?:\:[\dA-Fa-f]{1,4}){1,6}))(?:\/(19|[2-9]\d|1[01]\d|12[0-8]))?$/; // based on https://stackoverflow.com/a/17871737
const match = IPV4REGEX.exec(userName) || IPV6REGEX.exec(userName);
if (match) {
const version = match[1].includes(':') ? 6 : 4;
const ip = match[1];
const mask = parseInt(match[2] || (version === 6 ? '128' : '32'), 10);
return { version, ip, mask };
}
return null;
}
 
// generate sequence of numbers
function sequence(n, m, step = 1) {
for (var i = n, r = []; i <= m; i += step) r.push(i);
return r;
}
 
// add IP to array
function ipListAdd(ipList, ip) {
if (!ipList.some(i => i.ip === ip.ip && i.mask === ip.mask && i.version === ip.version)) {
ipList.push(ip);
}
}
 
// remove IP from array
function ipListRemove(ipList, ip) {
const index = ipList.findIndex(i => i.ip === ip.ip && i.mask === ip.mask && i.version === ip.version);
if (index !== -1) {
ipList.splice(index, 1);
}
}
 
// convert full IPv6 address to BigInt
function ipv6ToBigInt(ipv6) {
const segments = ipv6.split(':');
let bigIntValue = 0n;
const expanded = expandIPv6(segments);
expanded.forEach(segment => {
bigIntValue = (bigIntValue << 16n) + BigInt(parseInt(segment, 16));
});
return bigIntValue;
}
 
// expand shorthand IPv6 (e.g., '::1' to '0:0:0:0:0:0:0:1')
function expandIPv6(segments) {
const expanded = [];
let hasEmpty = false;
segments.forEach(segment => {
if (segment === '' && !hasEmpty) {
expanded.push(...Array(8 - segments.filter(s => s).length).fill('0'));
hasEmpty = true;
} else if (segment === '') {
expanded.push('0');
} else {
expanded.push(segment);
}
});
return expanded.map(seg => seg.padStart(4, '0'));
}
 
// apply mask to BigInt for IPv6
function applyMask(bigIntValue, prefixLength) {
const maskBits = 128 - prefixLength;
const mask = (1n << BigInt(128 - maskBits)) - 1n;
return bigIntValue & (mask << BigInt(maskBits));
}
 
// convert BigInt back to IPv6 string
function bigIntToIPv6(bigIntValue, prefixLength = 128) {
const segments = [];
for (let i = 0; i < 8; i++) {
const segment = (bigIntValue >> BigInt((7 - i) * 16)) & 0xffffn;
segments.push(segment.toString(16));
}
const ipv6 = segments.join(':').replace(/(^|:)0(:0)+(:|$)/, '::');
return ipv6 + (prefixLength < 128 ? `/${prefixLength}` : '');
}
 
// generate masked IP range
function maskedIP(ip, prefixLength) {
return ip.version === 6 ? maskedIPv6(ip.ip, prefixLength) : maskedIPv4(ip.ip, prefixLength);
}
 
// generate masked IPv6 range
function maskedIPv6(ipv6, prefixLength) {
const bigIntValue = ipv6ToBigInt(ipv6);
const shift = 128 - prefixLength;
const mask = (1n << BigInt(128 - shift)) - 1n;
const masked = bigIntValue & (mask << BigInt(shift));
return bigIntToIPv6(masked, prefixLength);
}
 
// generate masked IPv4 range
function maskedIPv4(ipv4, prefixLength) {
const octets = ipv4.split('.').map(Number);
const intValue = (octets[0] << 24) | (octets[1] << 16) | (octets[2] << 8) | octets[3];
const mask = (1 << (32 - prefixLength)) - 1;
const masked = intValue & ~mask;
return [
(masked >>> 24) & 0xff,
(masked >>> 16) & 0xff,
(masked >>> 8) & 0xff,
masked & 0xff
].join('.') + `/${prefixLength}`;
}
 
Line 397 ⟶ 659:
const userTools = `(<a href="/wiki/User_talk:${block.user}" title="User talk:${block.user}">talk</a> | <span><a href="/wiki/Special:Contributions/${block.user}" title="Special:Contributions/${block.user}">contribs</a>)`;
const action = block.action === "reblock" ? "changed block settings for" : `${block.action}ed`;
const ipLink = `<a href="/wiki/Special:Contributions/${block.range}" title=""><bdi>${block.range.toString(false, true)}</bdi></a>`;
let restrictions = '';
if (block.params?.restrictions) {
Line 436 ⟶ 698:
}
 
// convert wikitext to HTML
async function wikitextToHTML(wikitext) {
if (wikitextCache.has(wikitext)) {
Line 464 ⟶ 725:
}
return wikitext;
}
 
function batch(items, maxSize) {
const minBins = Math.ceil(items.length / maxSize);
const bins = Array.from({length: minBins}, () => []);
items.forEach((item, i) => {
bins[i % minBins].push(item);
});
return bins;
}
 
function sequence(n, m, step = 1) {
let r = [];
for (let i = n; i <= m; i += step) r.push(i);
return r;
}
 
function ipListAdd(ipList, ip) {
if (!ipList.some(i => i.equals(ip))) ipList.push(ip);
}
 
function ipListRemove(ipList, ip) {
const index = ipList.findIndex(i => i.equals(ip));
if (index !== -1) ipList.splice(index, 1);
}
 
function commonPrefix(a, b) {
let i = 0;
while (i < a.length && i < b.length && a[i] === b[i]) {
i++;
}
return a.slice(0, i);
}
});
Retrieved from "https://en.wikipedia.org/wiki/User:Daniel_Quinlan/Scripts/RangeHelper.js"