☰

nuke button

kill 'em all

// ==UserScript==
// @name        nuke button
// @namespace   https://github.com/yassghn/nuke-button
// @version     2025-04-10
// @description kill 'em all
// @icon        https://www.svgrepo.com/download/528868/bomb-emoji.svg
// @author      yassghn
// @match       https://twitter.com/*
// @match       https://mobile.twitter.com/*
// @match       https://x.com/*
// @match       https://mobile.x.com/*
// @run-at      document-start
// @grant       none
// @license     OUI
// @require     https://cdn.jsdelivr.net/npm/[email protected]/dist/jquery.min.js
// ==/UserScript==

/* global $ */

(function () {
	'use strict';

	/**
	 * nuke-button
	 *
	 * config.mjs
	 */

	// config object
	const config = {
		projectName: 'nuke-button',
		debug: false,
		mobile: (window.location.href.startsWith('https://mobile')) ? true : false,
		behavior: {
			newTabOnError: false
		},
		selectors: {
			nukeButton: 'a[class="nuke-button"]',
			posts: 'div[data-testid="User-Name"]',
			hometl: 'div[aria-label="Timeline: Your Home Timeline"]',
			tl: 'div[aria-label*="Timeline:"]',
			statustl: 'div[aria-label="Timeline: Conversation"]',
			searchtl: 'div[aria-label="Timeline: Search timeline"]',
			status: 'article[data-testid="tweet"]',
			postHref: 'a[href*="status"]',
			avatar: 'div[data-testid="Tweet-User-Avatar"]',
			nav: 'div [role="navigation"]',
			profile: 'a[aria-label="Profile"]',
			kbd: 'a[href="/i/keyboard_shortcuts"]',
			communities: 'a[aria-label="Communities"]'
		},
		static: {
			icon: '💣',
			checkMark: '✔️',
			redCross: '❌'
		},
		features: {
			rweb_tipjar_consumption_enabled: true,
			responsive_web_graphql_exclude_directive_enabled: true,
			verified_phone_label_enabled: false,
			creator_subscriptions_tweet_preview_api_enabled: true,
			responsive_web_graphql_timeline_navigation_enabled: true,
			responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
			communities_web_enable_tweet_community_results_fetch: true,
			c9s_tweet_anatomy_moderator_badge_enabled: true,
			articles_preview_enabled: true,
			responsive_web_edit_tweet_api_enabled: true,
			graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
			view_counts_everywhere_api_enabled: true,
			longform_notetweets_consumption_enabled: true,
			responsive_web_twitter_article_tweet_consumption_enabled: true,
			tweet_awards_web_tipping_enabled: false,
			creator_subscriptions_quote_tweet_preview_enabled: false,
			freedom_of_speech_not_reach_fetch_enabled: true,
			standardized_nudges_misinfo: true,
			tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
			rweb_video_timestamps_enabled: true,
			longform_notetweets_rich_text_read_enabled: true,
			longform_notetweets_inline_media_enabled: true,
			responsive_web_enhance_cards_enabled: false,
			blue_business_profile_image_shape_enabled: false,
			tweetypie_unmention_optimization_enabled: true,
			responsive_web_text_conversations_enabled: true,
			vibe_api_enabled: true,
			responsive_web_twitter_blue_verified_badge_is_enabled: false,
			interactive_text_enabled: true,
			longform_notetweets_richtext_consumption_enabled: true,
			premium_content_api_read_enabled: true,
			profile_label_improvements_pcf_label_in_post_enabled: true,
			responsive_web_grok_analyze_post_followups_enabled: false,
			responsive_web_grok_analyze_button_fetch_trends_enabled: false,
			responsive_web_grok_share_attachment_enabled: false
		},
		fieldToggles: {
			count: 1000,
			rankingMode: "Relevance",
			withSafetyModeUserFields: true,
			includePromotedContent: true,
			withQuickPromoteEligibilityTweetFields: true,
			withVoice: true,
			withV2Timeline: true,
			withDownvotePerspective: false,
			withBirdwatchNotes: true,
			withCommunity: true,
			withSuperFollowsUserFields: true,
			withReactionsMetadata: false,
			withReactionsPerspective: false,
			withSuperFollowsTweetFields: true,
			isMetatagsQuery: false,
			withReplays: true,
			withClientEventToken: false,
			withAttachments: true,
			withConversationQueryHighlights: true,
			withMessageQueryHighlights: true,
			withMessages: true,
			with_rux_injections: false
		},
		apiEndpoints: {
			tweetDetail: 'https://x.com/i/api/graphql/nBS-WpgA6ZG0CyNHD517JQ/TweetDetail',
			following: 'https://x.com/i/api/graphql/eWTmcJY3EMh-dxIR7CYTKw/Following',
			followers: 'https://x.com/i/api/graphql/pd8Tt1qUz1YWrICegqZ8cw/Followers',
			retweeters: 'https://x.com/i/api/graphql/0BoJlKAxoNPQUHRftlwZ2w/Retweeters',
			verifiedFollowers: 'https://x.com/i/api/graphql/srYtCtUs5BuBPbYj7agW6A/BlueVerifiedFollowers',
			userid: 'https://x.com/i/api/graphql/sLVLhk0bGj3MVFEKTdax1w/UserByScreenName',
			blockUser: 'https://x.com/i/api/1.1/blocks/create.json'
		}
	};

	/**
	 * nuke-button
	 *
	 * globals.mjs
	 */


	// globals
	var gCurrentPage = '';
	var gObservers = {};
	var gProfile = '';
	var gPageChanged = false;
	var gWhiteList = [];

	// init profile href
	function initProfile() {
		// check if we're on a mobile device
		if (!config.mobile) {
			gProfile = $(config.selectors.profile).attr('href').split('/')[1];
		} else {
			gProfile = $(config.selectors.communities).attr('href').split('/')[1];
		}
	}

	// init observers
	function initObservers() {
		gObservers = { href: new MutationObserver(() => { }), timeline: new MutationObserver(() => { }) };
	}

	// init white list
	function initWhiteList() {
		// array of usernames to whitelist
		gWhiteList = ['boryshn', 'yassghn_', 'commet_w'];
	}

	// set current page
	function initCurrentPage() {
		gCurrentPage = window.location.href;
	}

	// update current page
	function setCurrentPage(page) {
		gCurrentPage = page;
	}

	function setPageChanged(changed) {
		gPageChanged = changed;
	}

	// init globals
	function initGlobals() {
		initCurrentPage();
		initObservers();
		initProfile();
		initWhiteList();
	}

	// disconnect observers
	function disconnectObservers() {
		for (let observer of gObservers) {
			observer.disconnect();
		}
	}

	/**
	 * nuke-button
	 *
	 * log.mjs
	 */


	// log
	function log(msg, err = false) {
		if (config.debug) {
			if (err) {
				console.error(msg);
			} else {
				console.log(msg);
			}
		}
	}

	function logObj(obj, depth = null) {
		if (config.debug) {
			console.dir(obj, { depth: depth });
		}
	}

	/**
	 * nuke-button
	 *
	 * fight-react.mjs
	 */


	// delete react state
	/* function deleteReactState() {
		if ($('div')[0].firstElementChild['wrappedJSObject']) {
			delete ($('div')[0].firstElementChild['wrappedJSObject'])
			return ''

		}
		if ($('div')[0].firstElementChild) {
			delete ($('div')[0].firstElementChild)

		}
		//const reactPropsKey = Object.keys(wrapped).find(key => key.startsWith('__reactProps'))
		//         //const state = wrapped[reactPropsKey].children?.props?.children?.props?.store?.getState()
		//         //delete(state)
	} */

	/**
	 *
	 * notes:
	 * reactProps.children.props.history ???
	 */
	/* async function removePostsReactProps(post, href) {
		const wrapped = $('div')[0].firstElementChild['wrappedJSObject'] || $('div')[0].firstElementChild
		const reactPropsKey = Object.keys(wrapped).find(key => key.startsWith('__reactProps'))
		const reactFiberKey = Object.keys(wrapped).find(key => key.startsWith('__reactFiber'))
		const reactProps = wrapped[reactPropsKey]
		const reactFiber = wrapped[reactFiberKey]
		logObj(reactFiber)
		logObj(reactProps)
		 delete(reactFiber.memorizedProps)
		 delete(reactFiber.stateNode)
		 delete(reactProps.children.props.children.props)
		//delete(wrapped[key])
		//wrapped[key] = {}
		//removeReactObjects(href)
		const article = $(post).find('article')[0].firstElementChild['wrappedJSObject']
		const keys = Object.keys(article).filter(key => key.startsWith('__react'))
		//console.dir(article, { depth: null })
		logObj(keys)
		keys.forEach((key) => {
			//logObj(article[key])
			if (article[key]) {
				delete (article[key])
			}
		})
		//logObj(article)
	} */

	// get react state
	function getReactState() {
		const wrapped = $('div')[0].firstElementChild['wrappedJSObject'] || $('div')[0].firstElementChild;
		const reactPropsKey = Object.keys(wrapped).find(key => key.startsWith('__reactProps'));
		const state = wrapped[reactPropsKey].children?.props?.children?.props?.store?.getState();
		return state
	}

	// remvoe post react object
	function removeReactObjects(href) {
		// todo: not sure how to approach hacking at the react obejcts
		//       need to stop them from repopulating the timeline with removed posts
		//       also causes page to crash needing to reload
		// get react state
		const reactState = getReactState();
		const statusId = href.split('/')[3];
		// get in-reply-to if it exists
		const inReply = reactState.entities.tweets.entities[statusId].in_reply_to_status_id_str;
		// remove react objects
		if (reactState.entities.tweets.entities[statusId]) {
			//delete(reactState.entities.tweets.entities[statusId])
			reactState.entities.tweets.entities[statusId].conversation_id_str = "1234";
		}
		if (reactState.entities.tweets.fetchStatus[statusId]) {
			delete (reactState.entities.tweets.fetchStatus[statusId]);
		}
		for (const key in reactState.urt) {
			if (reactState.urt[key].entries) {
				for (let i = 0; i < reactState.urt[key].entries.length; i++) {
					if (reactState.urt[key].entries[i]) {
						if (reactState.urt[key].entries[i].entryId.includes(statusId)) {
							//delete(reactState.urt[key].entries[i])
							reactState.urt[key].entries[i].entryId = 'noid-0000';
							reactState.urt[key].entries[i].sortIndex = "1234";
							reactState.urt[key].entries[i].type = 'nonexistingType';
						}
					}
				}
			}
		}
		for (const key in reactState.audio.conversationLookup) {
			if (reactState.audio.conversationLookup[key]) {
				for (let i = 0; i < reactState.audio.conversationLookup[key].length; i++) {
					delete (reactState.audio.conversationLookup[key][i]);
				}
			}
		}
	}

	// hide post from timeline
	function hidePost(post) {
		// hide html from timeline
		$(post).html('');
		$(post).hide();
	}

	/**
	 * nuke-button
	 *
	 * polling.mjs
	 */


	/**
	 * @param {string} selector
	 * @param {{
	*   name?: string
	*   stopIf?: () => boolean
	*   timeout?: number
	*   context?: Document | HTMLElement
	* }?} options
	* @returns {Promise<HTMLElement | null>}
	*/
	function getElement(selector, {
		name = null,
		stopIf = null,
		timeout = Infinity,
		context = document,
	} = {}) {
		return new Promise((resolve) => {
			let startTime = Date.now();
			let rafId;
			let timeoutId;

			function stop($element, reason) {
				resolve($element);
			}

			if (timeout !== Infinity) {
				timeoutId = setTimeout(stop, timeout, null, `${timeout}ms timeout`);
			}

			function queryElement() {
				let $element = context.querySelector(selector);
				if ($element) {
					log(`found element with selector: ${selector}`);
					stop($element);
				}
				else if (stopIf?.() === true) {
					stop(null, 'stopIf condition met');
				}
				else {
					log(`waiting for element with selector: ${selector}`);
					rafId = requestAnimationFrame(queryElement);
				}
			}

			queryElement();
		})
	}

	// poll for react state
	async function pollReactState() {
		// new promise
		const promise = new Promise((resolve) => {
			// interval id
			let intervalId = 0;
			// function to return react state
			function returnReactState(reactState) {
				log('found react state');
				logObj(reactState);
				// resolve react state
				resolve(reactState);
			}
			// poll for react state
			function poll() {
				// use set interval to poll
				intervalId = setInterval(function () {
					try {
						const reactState = getReactState();
						// clear interval
						clearInterval(intervalId);
						// resolve
						returnReactState(reactState);
					} catch (error) {
						log('waiting for react state...');
					}
				}, 1000);
			}
			// start polling
			poll();
		});
		return promise
	}

	// wait for user to login if necessary
	async function isLoggedIn(reactState) {
		// new promise
		const promise = new Promise((resolve) => {
			// interval id
			let intervalId = 0;
			// resolve promise
			function resolved() {
				log('user logged in');
				// resolve
				resolve(true);
			}
			// poll checking if user is logged in
			function pollLoggedIn() {
				// poll with set interval
				intervalId = setInterval(function () {
					//check href and window vars
					if (!(window?.__META_DATA__?.isLoggedIn == false) &&
						!window.location.href.includes('/i/flow/login')) {
						// clear interval
						clearInterval(intervalId);
						// resolve
						resolved();
					} else {
						// keep polling
						log('waiting for user login');
					}
				}, 1000);
			}
			// start polling
			pollLoggedIn();
		});
		// return promise
		return promise
	}

	/**
	 * nuke-button
	 *
	 * api-data.mjs
	 */

	// extract item content from tweet responses
	function extractTweetResponseItemContent(entry) {
		if (entry.content.entryType === 'TimelineTimelineItem')
			return [entry.content.itemContent]
		if (entry.content.entryType === 'TimelineTimelineModule')
			return entry.content.items.map((item) => item.item.itemContent)
		return []
	}

	// check if item content is a tweet entry
	function isTweetEntry(itemContent) {
		return (
			itemContent.itemType === 'TimelineTweet' &&
			itemContent.tweet_results.result.__typename !== 'TweetWithVisibilityResults' &&
			itemContent.tweet_results.result.__typename !== 'TweetTombstone'
		)
	}

	// extract user id from data
	function extractUserId(data) {
		return data?.data?.user?.result?.rest_id
	}

	// extract user response data from instructions
	function extractUserResponseData(instructions) {
		const data = instructions
			.flatMap((instr) => instr.entries || [])
			.filter(
				(entry) =>
					entry.content.entryType === "TimelineTimelineItem" &&
					entry.content.itemContent.user_results.result &&
					entry.content.itemContent.user_results.result.__typename !== "UserUnavailable"
			)
			.map((entry) => ({
				username: entry.content.itemContent.user_results.result.legacy?.screen_name,
				isBlocked: entry.content.itemContent.user_results.result.legacy.blocking ??
					entry.content.itemContent.user_results.result.smart_blocking ??
					false,
				userId: entry.content.itemContent.user_results.result?.rest_id
			})) || [];
		return data
	}

	// extract user response data from instructions
	function extractTweetResponseData(instructions) {
		const entries = instructions.flatMap((instr) => instr.entries || []);
		// collect targets
		let responseTargets = [];
		// iterate instructions
		for (const entry of entries) {
			// get item contents
			const itemContents = extractTweetResponseItemContent(entry);
			// iterate item contents
			for (const itemContent of itemContents) {
				if (isTweetEntry(itemContent)) {
					const userId = itemContent.tweet_results.result.legacy.user_id_str;
					const username = itemContent.tweet_results.result.core.user_results.result.legacy.screen_name;
					const responseTarget = { username: username, isBlocked: false, userId: userId };
					responseTargets.push(responseTarget);
				}
			}
		}
		return responseTargets
	}

	/**
	 * nuke-button
	 *
	 * browser.mjs
	 */


	// open href in new tab
	function openHrefInNewTab(href) {
		// complete url
		const url = `https://x.com${href}`;
		log(`opening url: ${url}`);
		// open new tab
		window.open(url, '_blank');
		//window.focus()
	}

	/**
	 * nuke-button
	 *
	 * whitelist.mjs
	 */


	// filter block list
	function filterDedupWhiteList(item, index, arr) {
		// do not include white listed accounts
		if (gWhiteList.indexOf(item.username) > -1) {
			return false
		}
		// dedup based username and userid
		const i = arr.findIndex((item2) => ['username', 'userId'].every((key) => item2[key] === item[key]));
		return i === index
	}

	/**
	 * nuke-button
	 *
	 * api-request.mjs
	 */


	// get cookie
	function getCookie(cname) {
		const name = cname + '=';
		const ca = document.cookie.split(';');
		for (let i = 0; i < ca.length; ++i) {
			const c = ca[i].trim();
			if (c.indexOf(name) === 0) {
				return c.substring(name.length, c.length)
			}
		}
		return ''
	}

	// api request headers
	function createRequestHeaders() {
		const headers = {
			Authorization: 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA',
			'X-Twitter-Auth-Type': 'OAuth2Session',
			'X-Twitter-Active-User': 'yes',
			'X-Csrf-Token': getCookie('ct0')
		};
		return headers
	}

	// Universal API request function for making requests
	async function apiRequest(url, method = 'GET', body = null) {
		const options = {
			headers: createRequestHeaders(),
			method,
			credentials: 'include'
		};
		if (body) {
			options.body = body;
			options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
		}
		try {
			const response = await fetch(url, options);
			// check for errors
			if (response.ok) {
				// return data
				const data = await response.json();
				return data
			} else {
				// throw response error
				const errors = await response.json();
				throw errors
			}
		} catch (error) {
			// add url to error
			error.url = url;
			//throw error
			throw error
		}
	}

	// build api url
	function buildUrl(endpoint, variables) {
		// start with endpoint
		const url = `${endpoint}` +
			`?variables=${encodeURIComponent(JSON.stringify(Object.assign(variables, config.fieldToggles)))}` +
			`&features=${encodeURIComponent(JSON.stringify(config.features))}`;
		return url
	}

	// Fetches the list of users a given user is following
	async function fetchUserFollowing(userId) {
		const variables = {
			userId
		};
		const url = buildUrl(config.apiEndpoints.following, variables);
		try {
			const data = await apiRequest(url);
			return data
		} catch (e) {
			throw e
		}
	}

	// fetch users followers
	async function fetchUserFollowers(userId) {
		const variables = {
			userId
		};
		const url = buildUrl(config.apiEndpoints.followers, variables);
		try {
			const data = await apiRequest(url);
			return data
		} catch (e) {
			throw e
		}
	}

	// fetch verified followers
	async function fetchVerifiedFollowers(userId) {
		const variables = {
			userId: userId
		};
		const url = buildUrl(config.apiEndpoints.verifiedFollowers, variables);
		try {
			const data = await apiRequest(url);
			return data
		} catch (e) {
			throw e
		}
	}

	// Fetches responses for a tweet, with optional pagination cursor
	async function fetchTweetResponses(tweetId, cursor = null) {
		const variables = {
			focalTweetId: tweetId,
			cursor
		};
		const url = buildUrl(config.apiEndpoints.tweetDetail, variables);
		try {
			const data = await apiRequest(url);
			return data
		} catch (e) {
			throw e
		}
	}

	// fetch retweeters
	async function fetchTweetRetweeters(tweetId, cursor = null) {
		const variables = {
			tweetId: tweetId
		};
		const url = buildUrl(config.apiEndpoints.retweeters, variables);
		try {
			const data = await apiRequest(url);
			return data
		} catch (e) {
			throw e
		}
	}

	// blocks a user with the given user ID
	async function blockUser(userId) {
		try {
			const data = await apiRequest(config.apiEndpoints.blockUser, 'POST', `user_id=${userId}`);
			return data
		} catch (error) {
			throw error
		}
	}

	// fetch user id from username
	async function fetchUserId(username) {
		const variables = { screen_name: username };
		const url = buildUrl(config.apiEndpoints.userid, variables);
		try {
			const data = await apiRequest(url);
			return data
		} catch (e) {
			throw e
		}
	}

	// get block list
	async function getBlockList(userId, username, tweetId) {
		try {
			// get data
			const followingData = await fetchUserFollowing(userId);
			const following = extractUserResponseData(followingData?.data?.user?.result?.timeline?.timeline?.instructions);
			const followersData = await fetchUserFollowers(userId);
			const followers = extractUserResponseData(followersData?.data?.user?.result?.timeline?.timeline?.instructions);
			const verifiedFollowersData = await fetchVerifiedFollowers(userId);
			const verifiedFollowers = extractUserResponseData(verifiedFollowersData?.data?.user?.result?.timeline?.timeline?.instructions);
			const responsesData = await fetchTweetResponses(tweetId);
			const responses = extractTweetResponseData(responsesData?.data?.threaded_conversation_with_injections_v2?.instructions);
			const retweetersData = await fetchTweetRetweeters(tweetId);
			const retweeters = extractUserResponseData(retweetersData?.data?.retweeters_timeline?.timeline?.instructions);
			// add target user to front of array
			const target = [{ username: username, isBlocking: false, userId: userId }];
			// combine data
			const blockList = [].concat(target, following, followers, verifiedFollowers, responses, retweeters);
			// filter blocklist based on username and userid
			const filteredBlockList = blockList.filter(filterDedupWhiteList);
			// return block list
			return filteredBlockList
		} catch (e) {
			throw e
		}
	}

	// block a block list
	async function blockBlockList(blockList, href) {
		// init return
		let blockedTally = 0;
		let openedHref = false;
		// iterate block list
		for (const item of blockList) {
			// check if user is blocked already
			if (!item.isBlocked) {
				try {
					// block user
					const ret = await blockUser(item.userId);
					// increment blocked tally
					blockedTally += 1;
				} catch (error) {
					// log error
					log(`${error.name}, ${error.message}, ${error.cause}`, true);
					// something's going wrong, open post in new tab to finish nuke-ing later
					// probably got logged out (401), or api timeout (429)
					if (!openedHref && config.behavior.newTabOnError) {
						openHrefInNewTab(href);
						openedHref = true;
					}
				}
			}
		}
		// return success
		return blockedTally
	}

	/**
	 * nuke-button
	 *
	 * html-css.mjs
	 */


	// add processing html/css
	/* function addProcessingElement(post, href, style) {
	    // create processing html
	    const processingHtml = $(getProcessingHtml(href))
	    // make timeline item div wrappers
	    const divWrapper = $('<div/>')
	    const outterDivWrapper = $('<div/>')
	    const separatorDiv = $('<div/>')
	    const divWrapperClasses = $(post).children().eq(0).attr('class')
	    const outterDivWrapperClasses = $(post).attr('class')
	    const separatorClasses = $(post).find('div[role="separator"]').attr('class')
	    const transformCss = $(post).css('transform')
	    log(transformCss)
	    $(divWrapper).attr('class', divWrapperClasses)
	    $(outterDivWrapper).attr('class', outterDivWrapperClasses)
	    $(outterDivWrapper).attr('style', `transform: ${transformCss}; position: relative; width: 100%;`)
	    $(outterDivWrapper).attr('data-testid', 'cellInnerDiv')
	    $(separatorDiv).attr('class', separatorClasses)
	    $(separatorDiv).attr('role', 'separator')
	    // wrap divs
	    $(processingHtml).attr('class', outterDivWrapperClasses)
	    $(processingHtml).find('div').attr('class', outterDivWrapperClasses)
	    // add css to elements
	    $(processingHtml).css(getProcessingCss())
	    $(processingHtml).wrap($(outterDivWrapper)).wrap($(divWrapper))
	    const finalDiv = $(processingHtml).parents().eq(1)
	    $(finalDiv).append($(separatorDiv))
	    log($(separatorDiv))
	    log(finalDiv)
	    // add to dom
	    $(finalDiv).insertBefore($(post))
	    // return outter most div wrapper
	    return finalDiv
	} */

	// append style element to head
	function appendStyle() {
	    let $style = document.createElement('style');
	    $style.dataset.insertedBy = config.projectName;
	    $style.dataset.role = 'features';
	    document.head.appendChild($style);
	    return $style
	}

	// get twitter theme colors
	function getThemeColors() {
	    // get body style
	    const style = window.getComputedStyle($('body')[0]);
	    // try to get theme color from two different elements
	    const themeColor1 = style.getPropertyValue('--theme-color');
	    const themeColor2 = $(config.selectors.kbd).css('color');

	    return {
	        color: (themeColor1 != '') ? themeColor1 : themeColor2,
	        bg: style.getPropertyValue('background-color')
	    }
	}

	// nuke button css
	function getNukeButtonCss() {
	    const theme = getThemeColors();
	    const css =
	        `a.nuke-button {
                z-index: 1;
                position: absolute;
                width: 30px;
                height: 30px;
                top: 45px;
                text-decoration: none;
                text-align: center;
                user-select: none;
                -moz-user-select: none;
                -khtml-user-select: none;
                -webkit-user-select: none;
                -o-user-select: none;
            }
            a.nuke-button:hover {
                border-radius: 5px;
                background-color: ${theme.color};
            }
            #nuke-button {
                width: 100%;
                height: 100%;
                line-height: 30px;
            }
            #nuke-button-text {
                margin: 0 auto;
            }
            #processing-text {
                -moz-user-select: none;
                -khtml-user-select: none;
                -webkit-user-select: none;
                -o-user-select: none;
            }
            #processing-text span {
                display: inline-block;
                text-transform: uppercase;
                animation: flip 2s infinite;
                animation-delay: calc(.11s * var(--i));
            }
            #nuke-confirmation {
                height: 100px;
                width: 100%;
                text-align: center;
                justify-content: center;
                align-items: center;
                text-transform: uppercase;
                padding-top: 30px;
                border: 2px ${theme.color} solid;
                border-radius: 2px;
                box-shadow: inset 0 0 2px ${theme.bg},
                              inset 0 0 7px ${theme.bg},
                              inset 0 0 14px ${theme.color},
                              inset 0 0 21px ${theme.color},
                              inset 0 0 28px ${theme.color},
                              inset 0 0 35px ${theme.color};
                animation: glow 0.9s infinite alternate;
            }
            #nuke-confirmation-title {
                -moz-user-select: none;
                -khtml-user-select: none;
                -webkit-user-select: none;
                -o-user-select: none;
            }
            #nuke-confirmation-title span {
                display: inline-block;
                animation: flip 2s infinite;
                animation-delay: calc(.5s * var(--i));
            }
            .nuke-confirmation-button {
                display: inline-block;
                padding-left: 30px;
                padding-right: 30px;
            }
            .nuke-confirmation-button button {
                height: 50px;
                width: 80px;
                cursor: pointer;
                text-transform: uppercase;
            }
            @keyframes glow {
                100% {
                    box-shadow:
                           inset 0 0 3px ${theme.bg},
                           inset 0 0 10px ${theme.bg},
                           inset 0 0 20px ${theme.color},
                           inset 0 0 40px ${theme.color},
                           inset 0 0 70px ${theme.color},
                           inset 0 0 89px ${theme.color};
                }
            }
            @keyframes flip {
                0%,80% {
                    transform: rotateY(360deg);
                }
            }`;
	    return css
	}

	// nuke button html
	function getNukeButtonHtml() {
	    const nukeButtonHtml =
	        `<a class="nuke-button" data-testid="block">
                <div id="nuke-button">
                    <div id="nuke-button-text">
                        <span id="nuke-emoji">${config.static.icon}</span>
                    </div>
                </div>
            </a>`;
	    return nukeButtonHtml
	}

	// nuke confirmation html
	function getNukeConfirmationHtml() {
	    const nukeConfirmationHtml =
	        `<div id="nuke-confirmation">
                <div id="nuke-confirmation-title">
                    <span style="--i:1;">are</span>
                    <span style="--i:2;">you</span>
                    <span style="--i:3;">sure</span>
                    <span style="--i:4;">you</span>
                    <span style="--i:5;">want</span>
                    <span style="--i:6;">to</span>
                    <span style="--i:7;">nuke</span>
                    <span style="--i:8;">this</span>
                    <span style="--i:9;">thread?</span>
                </div>
                <br/>
                <div class="nuke-confirmation-button">
                    <button name="yes" type="button" value="true">
                        <span>${config.static.checkMark}</span>
                        <span>yes</span>
                    </button>
                </div>
                <div class="nuke-confirmation-button">
                    <button name="no" type="button" value="false">
                        <span>${config.static.redCross}</span>
                        <span>no</span>
                    </button>
                </div>
            </div>`;
	    return nukeConfirmationHtml
	}

	// get post href
	function getPostHref(post) {
	    // get target links attached to post
	    const links = $(post).find(config.selectors.postHref);
	    // iterate links
	    for (let i = 0; i < links.length; i++) {
	        // get href
	        const href = $(links[i]).attr('href');
	        // toss out incorrect links
	        if (href.includes('analytics') || href.includes('photo') || href.includes('history') || href.includes('retweets')) {
	            const arr = href.split('/');
	            const ret = `/${arr[1]}/${arr[2]}/${arr[3]}`;
	            return ret
	        } else if (i == links.length - 1) {
	            // return last link if none found
	            return href
	        }
	    }
	}

	// processing css
	function getProcessingCss() {
	    const theme = getThemeColors();
	    const css = {
	        'height': `100px`,
	        'text-align': 'center',
	        'justify-content': 'center',
	        'align-items': 'center',
	        'padding-top': '30px',
	        'border': `2px ${theme.color} solid`,
	        'border-radius': '2px',
	        'box-shadow': `inset 0 0 2px ${theme.bg},
                           inset 0 0 7px ${theme.bg},
                           inset 0 0 14px ${theme.color},
                           inset 0 0 21px ${theme.color},
                           inset 0 0 28px ${theme.color},
                           inset 0 0 35px ${theme.color}`,
	        'animation': 'glow 0.7s infinite alternate'
	    };
	    return css
	}

	// insert css
	function insertCss() {
	    let $style;
	    $style ??= appendStyle();
	    $style.textContent = getNukeButtonCss();
	}

	// edit status view css
	async function editStatusViewCss() {
	    // create css
	    const css = {
	        'z-index': -1,
	        'top': '17px'
	    };
	    // wait for element to load in
	    await getElement(config.selectors.status);
	    // add new style
	    $(config.selectors.status).find('div').eq(1).children().eq(2).css(css);
	}

	// html to display while processing is happening
	function getProcessingHtml(href) {
	    // remove leading slash from href
	    const info = href.substring(1, href.length);
	    // make processing text html
	    const processingTextHtml =
	        `<div id="processing-text">
                <span style="--i:1;">n</span>
                <span style="--i:2;">u</span>
                <span style="--i:3;">k</span>
                <span style="--i:4;">e</span>
                <span style="--i:5;">-</span>
                <span style="--i:6;">i</span>
                <span style="--i:7;">n</span>
                <span style="--i:8;">g</span>
                <span style="--i:10;">.</span>
                <span style="--i:11;">.</span>
                <span style="--i:12;">.</span>
            </div>`;
	    // combine and return
	    const processingHtml =
	        `<div id="processing"><article role="article" tabindex="0" data-testid="tweet">` +
	        `${processingTextHtml}<br/>` +
	        `<span id="processing-info-text">${info}</span></article></div>`;
	    return processingHtml
	}

	/**
	 * nuke-button
	 *
	 * nuke-button.mjs
	 */


	// kill 'em all
	async function killEmAll(href) {
		// get username from href
		const targetUsername = href.split('/')[1];
		const tweetId = href.split('/')[3];
		try {
			// get user data
			const userData = await fetchUserId(targetUsername);
			// check for error
			if (userData.message) {
				// throw error
				throw userData.message
			}
			// extract user id
			const targetUserId = extractUserId(userData);
			const blockList = await getBlockList(targetUserId, targetUsername, tweetId);
			const result = await blockBlockList(blockList, href);
			log(`processing finished for ${href}: blocked ${result} accounts`);
		} catch (e) {
			// log error url
			if (e.url) {
				log(`api request error for url: ${e.url}`, true);
			}
			// log error
			log(e, true);
			return undefined
		}
		// return href on success
		return href
	}

	// rebind the nuke function
	function rebindNukeCommand(post) {
		$(post).find(config.selectors.nukeButton).on('click', nuke);
	}

	// check for quote tweet
	function isQuoteTweet(post) {
		// quoted tweets have two classes
		if ($(post).attr('class').split(/\s+/).length > 1) {
			const quote = $(post).parents().eq(6).find('span:contains("Quote")');
			return quote.length > 0
		}
		return false
	}

	// should add nuke button
	function shouldAddNukeButton(post) {
		// check if post is null
		if (post != null) {
			// do not add nuke button to self's own posts
			let profile = '';
			// check for quote tweet
			if (isQuoteTweet(post)) {
				profile = $(post).parents().eq(1).find('span:contains("@")').first().text().split('@')[1];
			} else {
				profile = $(post).parents().eq(1).find('a').first().attr('href').split('/')[1];
			}
			// white list check
			const whiteListed = gWhiteList.find((username) => username.toString() === profile.toString());
			// check against global profile variable and whitelist
			if (gProfile != profile && !whiteListed) {
				return true
			}
		}
		// default return
		return false
	}

	// append nuke button html to post
	function appendNukeButtonHtml(post) {
		// check if buke button should be added
		if (shouldAddNukeButton(post)) {
			// apend html
			$(post).parents().first().parents().first().append(getNukeButtonHtml());
			// arm nuke
			$(post).parents().eq(1).find(config.selectors.nukeButton).on('click', nuke);
		}
	}

	// insert nuke button html
	function addNukeButton() {
	    // todo: breaks opening post in new tab, link at the end, probably react is looking for last link
	    $(config.selectors.avatar).each((index, post) => { appendNukeButtonHtml(post); });
	}

	// nuke confirmation
	async function nukeConfirmation(post) {
	    // init return
	    let ret = false;
	    // store post html
	    const postHtml = $(post).html();
	    // set confirmation html
	    $(post).html(getNukeConfirmationHtml());
	    // add even listeners to buttons
	    const promise = new Promise((resolve) => {
	        // yes button
	        $(post).find('button[name="yes"]').on('click', function (event) {
	            resolve(true);
	        });
	        // no button
	        $(post).find('button[name="no"]').on('click', function (event) {
	            resolve(false);
	        });
	    });
	    // await confirmation response
	    await promise.then((result) => {
	        // store return value
	        ret = result;
	        // reset post html
	        $(post).html(postHtml);
	    });
	    // return result
	    return ret
	}

	// nuke
	async function nuke(event) {
		// get upper context
		const post = $(this).parents().eq(6);
		// get post href
		const href = getPostHref(post);
		// confirm nuke-ing
		if (await nukeConfirmation(post)) {
			// log
			log('NUKE-ing!: ...' + href);
			// append processing html
			$(post).html(getProcessingHtml(href));
			// add css to elements
			$(post).find('#processing').css(getProcessingCss());
			// start nuking!
			await killEmAll(href);
			// remove react object
			removeReactObjects(href);
			// todo: error reporting, syncing with view
			// hide post from timeline
			hidePost(post);
		} else {
			rebindNukeCommand(post);
		}
	}

	/**
	 * nuke-button
	 *
	 * observe.mjs
	 */


	// on timeline change
	function onTimelineChange(mutations) {
		for (const mutation of mutations) {
			// append nuke button
			$(mutation.addedNodes).find(config.selectors.avatar).each((index, post) => { appendNukeButtonHtml(post); });
		}
	}

	function isUserPage() {
		// try to get username
		const username = window.location.href.split('/')[3];
		const url = `/${username}/header_photo`;
		// test for user page
		if ($('div').find(`a[href="${url}"]`).length == 1) {
			log(':is user page:');
			return true
		}
		// return false
		return false
	}

	// build userpage timeline selector
	function getUserPageTimelineSelector() {
		// get user display name
		const displayName = $('div[data-testid="UserName"]').find('span').first().text();
		const selector = `div[aria-label="Timeline: ${displayName}’s posts"]`;
		return selector
	}

	// observe timeline
	async function observeTimeline(selector) {
		// create observer with callback
		const observer = new MutationObserver((mutations) => { onTimelineChange(mutations); });
		// disconnect old observer
		// todo: not sure if this is necessary, maybe modals disconnect it anyway?
		gObservers.timeline.disconnect();
		gObservers.timeline = observer;
		// wait for timeline to load in
		await getElement(config.selectors.status);
		observer.observe($(selector).children().first()[0], { childList: true });
		// check if page has changed
		//if (!gPageChanged) {
		// add nuke button to initial posts
		addNukeButton();
		//}
	}

	// when home timeline navigation event is propagated
	function onHomeNavigationEvent() {
		// reset page changed if it was changed
		setPageChanged(false);
		// create timeline observer
		observeTimeline(config.selectors.hometl);
		log('home nav changed');
	}

	async function observeWindowHref() {
		setInterval(() => {
			// check if location changed
			if (gCurrentPage != window.location.href) {
				// update current page
				setCurrentPage(window.location.href);
				onWindowHrefChange();
			}
		}, 1000);
	}

	// observe for location changes
	function observeWindowHrefasdf() {
		// observer with callback
		const observer = new MutationObserver(() => {
			// check if location changed
			if (gCurrentPage != window.location.href) {
				// update current page
				setCurrentPage(window.location.href);
				onWindowHrefChange();
			}
		});
		gObservers.href.disconnect();
		gObservers.href = observer;
		observer.observe(document, { childList: true, subtree: true });
	}

	// process current page
	async function processCurrentPage(updatePage = false) {
		// check href location
		if (window.location.href.endsWith('home')) {
			// check for home
			// todo: work out updating this value after more back and forth browsing
			// todo: work out race conditions where polling fails
			// update page changed
			setPageChanged(updatePage ? true : false);
			addHomeNavigationListener();
			// wait for timeline to load in
			await getElement(config.selectors.hometl);
			// todo: dethrottle polling when no posts are loading
			observeTimeline(config.selectors.hometl);
		} else if (isUserPage()) {
			// check for userpage
			// update page changed
			setPageChanged(updatePage ? true : false);
			// get userpage timeline selector
			const selector = getUserPageTimelineSelector();
			// wait for timeline to load in
			await getElement(selector);
			observeTimeline(selector);
		} else if (window.location.href.includes('status')) {
			// check for status (post) view page
			// todo: editstatusview does not update correctly sometimes
			// todo: if you need to use 'view' for the post nuke-button does not populate to the main status
			//update page changed
			setPageChanged(updatePage ? true : false);
			// wait for timeline to load in
			await getElement(config.selectors.statustl);
			// change status view css
			editStatusViewCss();
			// obvserve timeline
			observeTimeline(config.selectors.statustl);
		} else if (window.location.href.includes('search?q=')) {
			// check for search page
			//update page changed
			setPageChanged(updatePage ? true : false);
			// wait for timeline to load in
			await getElement(config.selectors.searchtl);
			// observe timeline
			observeTimeline(config.selectors.searchtl);
		}
	}

	async function onWindowHrefChange() {
		log(`window href changed: ${window.location.href}`);
		// wait for react state
		const reactState = await pollReactState();
		// wait for login if necessary
		await isLoggedIn(reactState);
		// process current page
		processCurrentPage(true);
	}

	// add navigation listener
	function addHomeNavigationListener() {
		// add event listener for timeline tabs
		$(config.selectors.nav).eq(1).on('mousedown', onHomeNavigationEvent);
	}

	// setup mutation observers
	function observeApp() {
		// add timeline observer
		processCurrentPage();
		// add window location poling
		observeWindowHref();
	}

	/**
	 * nuke-button
	 *
	 * nuke-button.user.js
	 */

	(function () {
	    'use strict';

	    // main
	    async function main() {
	        // wait for react state
	        const reactState = await pollReactState();
	        // wait for login if necessary
	        await isLoggedIn(reactState);
	        // wait for timeline to load in
	        await getElement(config.selectors.tl);
	        // init globals
	        initGlobals();
	        // insert css
	        insertCss();
	        // observe
	        observeApp();
	    }

	    // run script
	    window.onload = main();

	})();

})();