Raw Source Toggle Dropdown

• Minified Source

0xprateek / instagram-dm-unsender

// ==UserScript==

// @name				instagram-dm-unsender
// @license				MIT
// @copyright				Copyright (c) 2023, Romain Lebesle <oss@thoughtsunificator.me> (https://thoughtsunificator.me)
// @namespace				https://thoughtsunificator.me/
// @author				Romain Lebesle <oss@thoughtsunificator.me> (https://thoughtsunificator.me)
// @homepageURL				https://thoughtsunificator.me/
// @supportURL				https://thoughtsunificator.me/
// @contributionURL				https://thoughtsunificator.me/
// @icon				https://www.instagram.com/favicon.ico
// @version				0.7.2-patched
// @description				Simple script to unsend all DMs in a thread on instagram.com (patched 2026-05 for new Messages-in-conversation aria-label, profile-link sender heuristic, and DOM-verification fix)
// @run-at				document-end
// @include				/^https://(www\.)?instagram\.com/*/

// ==/UserScript==


(function (exports) {
	'use strict';

	/** @module instagram Helpers to mimick Instagram's look and feel */

	const BUTTON_STYLE = {
		"PRIMARY": "primary",
		"SECONDARY": "secondary",
	};

	/**
	 *
	 * @param {HTMLButtonElement} buttonElement
	 * @param {string}            styleName
	 */
	function applyButtonStyle(buttonElement, styleName) {
		buttonElement.style.fontSize = "var(--system-14-font-size)";
		buttonElement.style.color = "white";
		buttonElement.style.border = "0px";
		buttonElement.style.borderRadius = "8px";
		buttonElement.style.padding = "8px";
		buttonElement.style.fontWeight = "bold";
		buttonElement.style.cursor = "pointer";
		buttonElement.style.lineHeight = "var(--system-14-line-height)";
		if(styleName) {
			buttonElement.style.backgroundColor = `rgb(var(--ig-${styleName}-button))`;
		}
	}

	/** @module menu-button Helpers to create buttons that can be used in IDMU's menu */


	/**
	 *
	 * @param {Document} document
	 * @param {string}   text
	 * @param {string}   styleName
	 * @returns {HTMLButtonElement}
	 */
	function createMenuButtonElement(document, text, styleName) {
		const buttonElement = document.createElement("button");
		buttonElement.textContent = text;
		applyButtonStyle(buttonElement, styleName);
		buttonElement.addEventListener("mouseover", () => {
			buttonElement.style.filter = `brightness(1.15)`;
		});
		buttonElement.addEventListener("mouseout", () => {
			buttonElement.style.filter = ``;
		});
		return buttonElement
	}

	/** @module menu IDMU's main menu */

	/**
	 * @param {Document} document
	 * @returns {HTMLButtonElement}
	 */
	function createMenuElement(document) {
		const menuElement = document.createElement("div");
		menuElement.id = "idmu-menu";
		menuElement.style.top = "20px";
		menuElement.style.right = "430px";
		menuElement.style.position = "fixed";
		menuElement.style.zIndex = 999;
		menuElement.style.display = "flex";
		menuElement.style.gap = "10px";
		menuElement.style.placeItems = "center";
		return menuElement
	}

	/** @module async-events Utils module for finding elements asynchronously in the DOM */

	/**
	 *
	 * @callback getElement
	 * @returns {Element}
	 */

	/**
	 *
	 * @param {Element} target
	 * @param {getElement} getElement
	 * @param {AbortController} abortController
	 * @returns {Promise<Element>}
	 */
	function waitForElement(target, getElement, abortController) {
		return new Promise((resolve, reject) => {
			let mutationObserver;
			const abortHandler = () => {
				if(mutationObserver) {
					reject(new DOMException("Aborted: Disconnecting mutation observer...", "AbortError"));
					mutationObserver.disconnect();
				} else {
					reject(new DOMException("Aborted", "AbortError"));
				}
			};
			abortController.signal.addEventListener("abort", abortHandler);
			let element = getElement();
			if(element) {
				resolve(element);
				abortController.signal.removeEventListener("abort", abortHandler);
			} else {
				mutationObserver = new MutationObserver((mutations, observer) => {
					element = getElement(mutations);
					if(element) {
						observer.disconnect();
						resolve(element);
						abortController.signal.removeEventListener("abort", abortHandler);
					}
				});
				mutationObserver.observe(target, { subtree: true, childList:true });
			}
		})
	}

	/**
	 *
	 * @param {Element} clickTarget
	 * @param {Element} target
	 * @param {getElement} getElement
	 * @param {AbortController} abortController
	 * @returns {Element|Promise<Element>}
	 */
	function clickElementAndWaitFor(clickTarget, target, getElement, abortController) {
		const promise = waitForElement(target, getElement, abortController);
		clickTarget.click();
		return getElement() || promise
	}

	/** @module ui-component Base class for any element that is a part of the UI. */


	/**
	 *
	 * @abstract
	 */
	class UIComponent {
		/**
		 *
		 * @param {Element} root
		 * @param {object} identifier
		 */
		constructor(root, identifier={}) {
			this.root = root;
			this.identifier = identifier;
		}

		/**
		 *
		 * @param {Element} target
		 * @param {function} getElement
		 * @param {AbortController} abortController
		 * @returns {Promise<Element>}
		 */
		waitForElement(target, getElement, abortController) {
			return getElement() || waitForElement(target, getElement, abortController)
		}

		/**
		 *
		 * @param {Element} clickTarget
		 * @param {Element} target
		 * @param {function} getElement
		 * @param {AbortController} abortController
		 * @returns {Promise<Element>}
		 */
		clickElementAndWaitFor(clickTarget, target, getElement, abortController) {
			return clickElementAndWaitFor(clickTarget, target, getElement, abortController)
		}

	}

	/** @module ui-message UI element representing a message */


	/** Locale-independent patterns for the "Unsend" menu item */
	const UNSEND_TEXT_VARIANTS = [
		"unsend",        // English
		"annulla invio", // Italian
		"retirar",       // Portuguese
		"deshacer",      // Spanish
		"retirer",       // French
		"zurücknehmen",  // German
	];

	/**
	 * Dispatches pointer and mouse hover events on a target element.
	 * Instagram's React uses pointer events internally; mouse events alone are insufficient.
	 *
	 * @param {Element} target
	 */
	function dispatchHoverIn(target) {
		const rect = target.getBoundingClientRect();
		const opts = {
			bubbles: true,
			cancelable: true,
			clientX: rect.x + rect.width / 2,
			clientY: rect.y + rect.height / 2,
			pointerId: 1,
			pointerType: "mouse",
		};
		target.dispatchEvent(new PointerEvent("pointerenter", { ...opts, bubbles: false }));
		target.dispatchEvent(new PointerEvent("pointerover", opts));
		target.dispatchEvent(new PointerEvent("pointermove", opts));
		target.dispatchEvent(new MouseEvent("mouseenter", { ...opts, bubbles: false }));
		target.dispatchEvent(new MouseEvent("mouseover", opts));
		target.dispatchEvent(new MouseEvent("mousemove", opts));
	}

	/**
	 * Dispatches pointer and mouse leave events on a target element.
	 *
	 * @param {Element} target
	 */
	function dispatchHoverOut(target) {
		const rect = target.getBoundingClientRect();
		const opts = {
			bubbles: true,
			cancelable: true,
			clientX: rect.x + rect.width / 2,
			clientY: rect.y + rect.height / 2,
			pointerId: 1,
			pointerType: "mouse",
		};
		target.dispatchEvent(new PointerEvent("pointerout", opts));
		target.dispatchEvent(new PointerEvent("pointerleave", { ...opts, bubbles: false }));
		target.dispatchEvent(new MouseEvent("mouseout", opts));
		target.dispatchEvent(new MouseEvent("mouseleave", { ...opts, bubbles: false }));
	}

	class UIMessage extends UIComponent {

		/**
		 * Dismiss any stale dialog or dropdown left from a previous failed workflow.
		 */
		_dismissStaleOverlays() {
			const doc = this.root.ownerDocument;
			// Close stale confirmation dialogs
			const staleDialog = doc.querySelector("[role=dialog]");
			if (staleDialog) {
				console.debug("Dismissing stale dialog");
				const closeBtn = staleDialog.querySelector("button");
				if (closeBtn) closeBtn.click();
			}
			// Close stale dropdown menus by pressing Escape
			const activeMenu = doc.querySelector("[role=menu], [role=listbox]");
			if (activeMenu) {
				console.debug("Dismissing stale menu via Escape");
				doc.body.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
			}
		}

		/**
		 * Find the action button within the message row.
		 * Instagram moved aria-label from the button div to a nested SVG/title.
		 * Any match (SVG or div) is walked up to the nearest [role=button] ancestor.
		 *
		 * @param {Element} scope
		 * @returns {Element|null}
		 */
		_findActionButton(scope) {
			const LABEL_PATTERNS = [
				"[aria-label^='See more options for message']",
				"[aria-label*='more options']",
				"[aria-label*='More']",
				"[aria-label*='Altre opzioni']",
				"[aria-label*='opzioni']",
				"[aria-label*='opciones']",
				"[aria-label*='options']",
			];

			for (const sel of LABEL_PATTERNS) {
				const el = scope.querySelector(sel);
				if (el) {
					// Always resolve to a clickable button container
					const btn = el.closest("[role=button]") || el.closest("button");
					if (btn && scope.contains(btn)) return btn
					// el itself is already a button-like element
					if (el.tagName === "BUTTON" || el.getAttribute("role") === "button") return el
				}
			}

			// Fallback: any role=button with aria-haspopup=menu inside the message row
			return scope.querySelector("[role=button][aria-haspopup=menu]")
		}

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise<HTMLButtonElement>}
		 */
		async showActionsMenuButton(abortController) {
			console.debug("Workflow step 1 : showActionsMenuButton", this.root);
			this._dismissStaleOverlays();

			// Collect all hoverable ancestors from root down to the message bubble.
			// Instagram React listens at intermediate levels (role=group, flex-end wrapper).
			const hoverTargets = [this.root];
			const collectTargets = (el, depth) => {
				if (depth > 8) return
				for (const child of el.children) {
					hoverTargets.push(child);
					collectTargets(child, depth + 1);
				}
			};
			collectTargets(this.root, 0);

			// Try up to 3 times — hover events can be flaky
			for (let attempt = 0; attempt < 3; attempt++) {
				if (abortController.signal.aborted) return null

				for (const target of hoverTargets) {
					dispatchHoverIn(target);
				}

				await new Promise(resolve => setTimeout(resolve, 100));

				const btn = this._findActionButton(this.root);
				if (btn) {
					console.debug("Workflow step 1 : found action button on attempt", attempt, btn);
					return btn
				}

				console.debug("Workflow step 1 : attempt", attempt, "no button found, retrying...");
				dispatchHoverOut(this.root);
				await new Promise(resolve => setTimeout(resolve, 50));
			}

			// Final fallback: use waitForElement with extended timeout
			const waitAbortController = new AbortController();
			let promiseTimeout;
			const abortHandler = () => {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
			};
			abortController.signal.addEventListener("abort", abortHandler);

			for (const target of hoverTargets) {
				dispatchHoverIn(target);
			}

			try {
				const actionButton = await Promise.race([
					this.waitForElement(
						this.root,
						() => this._findActionButton(this.root),
						waitAbortController
					),
					new Promise((resolve, reject) => {
						promiseTimeout = setTimeout(() => reject("Timeout showActionsMenuButton"), 3000);
					})
				]);

				if (actionButton) {
					return actionButton
				}
				return actionButton
			} finally {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
				abortController.signal.removeEventListener("abort", abortHandler);
			}
		}

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise<boolean>}
		 */
		async hideActionMenuButton(abortController) {
			console.debug("hideActionMenuButton", this.root);
			dispatchHoverOut(this.root);

			const noneEl = this.root.querySelector("[role=none]");
			if (noneEl) {
				dispatchHoverOut(noneEl);
			}

			const waitAbortController = new AbortController();
			let promiseTimeout;
			let resolveTimeout;
			const abortHandler = () => {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
				if (resolveTimeout) {
					resolveTimeout();
				}
			};
			abortController.signal.addEventListener("abort", abortHandler);

			try {
				const result = await Promise.race([
					this.waitForElement(
						this.root,
						() => this._findActionButton(this.root) === null,
						waitAbortController
					),
					new Promise((resolve, reject) => {
						resolveTimeout = resolve;
						promiseTimeout = setTimeout(() => reject("Timeout hideActionMenuButton"), 500);
					})
				]);
				return result
			} finally {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
				abortController.signal.removeEventListener("abort", abortHandler);
			}
		}

		/**
		 * Opens the actions menu by clicking the action button and waiting for the "Unsend" item.
		 *
		 * @param {HTMLButtonElement} actionButton
		 * @param {AbortController} abortController
		 * @returns {Promise}
		 */
		async openActionsMenu(actionButton, abortController) {
			console.debug("Workflow step 2 : Clicking actionButton and waiting for unsend menu item to appear", actionButton);
			const waitAbortController = new AbortController();
			let promiseTimeout;
			const abortHandler = () => {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
			};
			abortController.signal.addEventListener("abort", abortHandler);

			/** Check if text matches any known "Unsend" variant */
			const isUnsendText = (text) => {
				const normalized = text.trim().toLocaleLowerCase();
				return UNSEND_TEXT_VARIANTS.some(v => normalized === v)
			};

			try {
				const unsendButton = await Promise.race([
					this.clickElementAndWaitFor(
						actionButton,
						this.root.ownerDocument.body,
						(mutations) => {
							if (mutations) {
								const addedNodes = [...mutations.map(mutation => [...mutation.addedNodes])].flat().filter(node => node.nodeType === 1);
								for (const addedNode of addedNodes) {
									const node = [...addedNode.querySelectorAll("span,div")].find(node => isUnsendText(node.textContent) && node.firstChild?.nodeType === 3);
									if (node) {
										console.debug("Workflow step 2 : found unsend node via mutation", node);
										return node
									}
								}
							}
							// Fallback: scan the whole document for an unsend menu item already present
							const allSpans = this.root.ownerDocument.querySelectorAll("[role=menu] span, [role=menu] div, [role=menuitem] span, [role=menuitem] div");
							for (const span of allSpans) {
								if (isUnsendText(span.textContent) && span.firstChild?.nodeType === 3) {
									console.debug("Workflow step 2 : found unsend node via document scan", span);
									return span
								}
							}
						},
						waitAbortController
					),
					new Promise((resolve, reject) => {
						promiseTimeout = setTimeout(() => reject("Timeout openActionsMenu"), 3000);
					})
				]);

				console.debug("Workflow step 2 : Found unsendButton", unsendButton);
				return unsendButton
			} finally {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
				abortController.signal.removeEventListener("abort", abortHandler);
			}
		}

		/**
		 * Closes the actions menu.
		 *
		 * @param {HTMLButtonElement} actionButton
		 * @param {HTMLDivElement} actionsMenuElement
		 * @param {AbortController} abortController
		 * @returns {Promise<boolean>}
		 */
		async closeActionsMenu(actionButton, actionsMenuElement, abortController) {
			console.debug("closeActionsMenu");
			const waitAbortController = new AbortController();
			let promiseTimeout;
			const abortHandler = () => {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
			};
			abortController.signal.addEventListener("abort", abortHandler);

			try {
				const result = await Promise.race([
					this.clickElementAndWaitFor(
						actionButton,
						this.root.ownerDocument.body,
						() => this.root.ownerDocument.body.contains(actionsMenuElement) === false,
						abortController
					),
					new Promise((resolve, reject) => {
						promiseTimeout = setTimeout(() => reject("Timeout closeActionsMenu"), 500);
					})
				]);
				return result !== null
			} finally {
				waitAbortController.abort();
				clearTimeout(promiseTimeout);
				abortController.signal.removeEventListener("abort", abortHandler);
			}
		}

		/**
		 * Click unsend button and wait for the confirmation dialog.
		 *
		 * @param {HTMLSpanElement} unsendButton
		 * @param {AbortController} abortController
		 * @returns {Promise<HTMLButtonElement>|Promise<Error>}
		 */
		openConfirmUnsendModal(unsendButton, abortController) {
			console.debug("Workflow step 3 : Clicking unsendButton and waiting for dialog to appear...");
			return this.clickElementAndWaitFor(
				unsendButton,
				this.root.ownerDocument.body,
				() => this.root.ownerDocument.querySelector("[role=dialog] button"),
				abortController
			)
		}

		/**
		 * Click unsend confirm button in the modal dialog.
		 *
		 * @param {HTMLButtonElement} dialogButton
		 * @param {AbortController} abortController
		 * @returns {Promise}
		 */
		async confirmUnsend(dialogButton, abortController) {
			console.debug("Workflow final step : confirmUnsend", dialogButton);
			await this.clickElementAndWaitFor(
				dialogButton,
				this.root.ownerDocument.body,
				() => this.root.ownerDocument.querySelector("[role=dialog] button") === null,
				abortController
			);
		}

	}

	/** @module uipi-message API for UIMessage */


	class FailedWorkflowException extends Error {}

	class UIPIMessage {

		/**
		 * @param {UIMessage} uiMessage
		 */
		constructor(uiMessage) {
			this._uiMessage = uiMessage;
		}

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise<boolean>}
		 */
		async unsend(abortController) {
			console.debug("UIPIMessage unsend");
			let actionButton;
			let unsendButton;
			try {
				actionButton = await this.uiMessage.showActionsMenuButton(abortController);
				unsendButton = await this.uiMessage.openActionsMenu(actionButton, abortController);
				console.debug("unsendButton", unsendButton);
				const dialogButton = await this.uiMessage.openConfirmUnsendModal(unsendButton, abortController);
				await this.uiMessage.confirmUnsend(dialogButton, abortController);
				this.uiMessage.root.setAttribute("data-idmu-unsent", "");
				return true
			} catch(ex) {
				console.error(ex);
				this.uiMessage.root.setAttribute("data-idmu-ignore", "");
				// Dismiss any open overlay so the next message starts clean
				try {
					const doc = this.uiMessage.root.ownerDocument;
					doc.body.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
					await new Promise(resolve => setTimeout(resolve, 200));
					// If dialog is still open, press Escape again
					if (doc.querySelector("[role=dialog]")) {
						doc.body.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
						await new Promise(resolve => setTimeout(resolve, 200));
					}
				} catch (_) { /* best-effort cleanup */ }
				throw new FailedWorkflowException("Failed to execute workflow for this message", ex)
			}
		}

		/**
		 * @type {UIMessage}
		 */
		get uiMessage() {
			return this._uiMessage
		}

	}

	/**
	 *
	 * @abstract
	 */
	class UI extends UIComponent {

		/**
		 *
		 * @abstract
		 * @returns {UI}
		 */
		static create() {
		}

		/**
		 *
		 * @abstract
		 * @param {AbortController} abortController
		 * @returns {Promise}
		 */
		/* eslint-disable-next-line no-unused-vars */
		async fetchAndRenderThreadNextMessagePage(abortController) {
		}

		/**
		 *
		 * @abstract
		 * @returns {Promise<UIPIMessage>}
		 */
		async getNextUIPIMessage() {
		}

	}

	/** @module dom-lookup Utils module for looking up elements on the default UI */


	/**
	 * Returns true when the element looks like the messages scroll container
	 * (vertically scrollable AND large enough to be the main thread pane).
	 *
	 * @param {Element} el
	 * @param {Window} window
	 * @returns {boolean}
	 */
	function isMessagesScrollable(el, window) {
		if (!el || el.nodeType !== 1) return false
		const style = window.getComputedStyle(el);
		if (style.overflowY !== "auto" && style.overflowY !== "scroll") return false
		if (el.scrollHeight <= el.clientHeight) return false
		const rect = el.getBoundingClientRect();
		// Ignore narrow side rails (chats list is typically 320–400 px) and
		// tiny widgets. The right-hand thread pane is almost always wider.
		return rect.width >= 420 && rect.height >= 200
	}

	/**
	 * Returns true when `el` lives in the same visual column as the composer
	 * (so we don't accidentally pick the chats sidebar) AND sits above it
	 * (the message composer is always at the bottom of the thread pane).
	 *
	 * @param {Element} el
	 * @param {DOMRect} composerRect
	 * @returns {boolean}
	 */
	function isAlignedWithComposer(el, composerRect) {
		const r = el.getBoundingClientRect();
		const sameColumn = Math.abs(r.left - composerRect.left) <= 80
			&& Math.abs(r.right - composerRect.right) <= 80;
		const aboveComposer = r.bottom <= composerRect.top + 10;
		return sameColumn && aboveComposer
	}

	/**
	 * Finds the message composer ([contenteditable=true] textbox at the
	 * bottom of the thread pane). The composer is the most stable landmark
	 * in Instagram's DM page — its aria-label changes locale-by-locale but
	 * the contenteditable+textbox shape doesn't.
	 *
	 * @param {Document} doc
	 * @returns {Element|null}
	 */
	function findComposer(doc) {
		const candidates = [
			"[contenteditable=true][aria-label^='Message ']",
			"[contenteditable=true][role=textbox][aria-label]",
			"div[role=textbox][contenteditable=true]",
			"[contenteditable=true][aria-label]",
			"[contenteditable=true][role=textbox]",
			"[contenteditable=true]",
		];
		for (const sel of candidates) {
			const el = doc.querySelector(sel);
			if (el) {
				console.debug("findComposer: matched", sel, el);
				return el
			}
		}
		return null
	}

	/**
	 * Walks up from the composer and finds a scrollable that:
	 *   - isn't an ancestor or descendant of the composer
	 *   - is in the same visual column as the composer
	 *   - sits above the composer
	 *
	 * @param {Element} composer
	 * @param {Window} window
	 * @returns {Element|null}
	 */
	function findMessagesScrollableNearby(composer, window) {
		const composerRect = composer.getBoundingClientRect();
		let cursor = composer.parentElement;
		while (cursor && cursor !== cursor.ownerDocument.body) {
			for (const el of cursor.querySelectorAll("div")) {
				if (el === composer || el.contains(composer) || composer.contains(el)) continue
				if (!isMessagesScrollable(el, window)) continue
				if (!isAlignedWithComposer(el, composerRect)) continue
				return el
			}
			cursor = cursor.parentElement;
		}
		return null
	}

	/**
	 * Finds the scrollable messages container inside the conversation panel.
	 *
	 * Strategy ladder (each step is a fallback for the previous one):
	 *   1. Locate the message composer and walk up to find a scrollable
	 *      that sits in the SAME visual column as the composer and ABOVE
	 *      it. This is the most reliable signal because:
	 *        - the composer is always in the right thread pane,
	 *        - the chats list (left sidebar) is in a different column.
	 *   2. Match a known wrapper aria-label (specific patterns only — the
	 *      bare "Conversation" prefix is intentionally NOT used because it
	 *      also matches the plural "Conversations" of the chats list).
	 *   3. As a last resort, pick the largest scrollable element inside
	 *      <main> that is also aligned with the composer's column.
	 *
	 * If everything fails we dump diagnostics to the console so the user
	 * can paste them back and we can extend the matchers.
	 *
	 * @param {Window} window
	 * @returns {HTMLDivElement|null}
	 */
	function findMessagesWrapper(window) {
		const doc = window.document;
		const composer = findComposer(doc);

		// 1) composer-anchored search (primary)
		if (composer) {
			const found = findMessagesScrollableNearby(composer, window);
			if (found) {
				console.debug("findMessagesWrapper [step 1]: scrollable in composer's column", found);
				return found
			}
		}

		// 2) aria-label match — only patterns that uniquely identify the
		//    open thread (NOT the chats list).
		const ariaSelectors = [
			"[aria-label^='Messages in conversation with']",
			"[aria-label*='Messages in conversation with']",
			"[aria-label^='Conversation with ']",
			"[aria-label^='Thread with ']",
		];
		for (const sel of ariaSelectors) {
			const conv = doc.querySelector(sel);
			if (!conv) continue
			console.debug("findMessagesWrapper [step 2]: matched", sel, conv);
			const scrollable = findScrollableChild(conv, window);
			if (scrollable && (!composer ||
				isAlignedWithComposer(scrollable, composer.getBoundingClientRect()))) {
				return scrollable
			}
			if (isMessagesScrollable(conv, window) && (!composer ||
				isAlignedWithComposer(conv, composer.getBoundingClientRect()))) {
				return conv
			}
		}

		// 3) largest column-aligned scrollable inside <main>
		if (composer) {
			const composerRect = composer.getBoundingClientRect();
			const main = doc.querySelector("main, [role=main]") || doc.body;
			let best = null;
			let bestArea = 0;
			for (const el of main.querySelectorAll("div")) {
				if (!isMessagesScrollable(el, window)) continue
				if (!isAlignedWithComposer(el, composerRect)) continue
				const r = el.getBoundingClientRect();
				const area = r.width * r.height;
				if (area > bestArea) {
					best = el;
					bestArea = area;
				}
			}
			if (best) {
				console.debug("findMessagesWrapper [step 3]: largest column-aligned scrollable", best);
				return best
			}
		}

		// All strategies failed — emit diagnostics for the user to share.
		console.error("findMessagesWrapper: no candidate found. Diagnostics follow:");
		console.error("URL:", window.location.href);
		console.error("composer (raw):", composer);
		if (composer) {
			console.error("composer outerHTML (first 600 chars):",
				(composer.outerHTML || "").slice(0, 600));
			console.error("composer rect:", composer.getBoundingClientRect());
			console.error("composer ancestor tags up to <main>:",
				(function () {
					const path = [];
					let c = composer;
					while (c && c.tagName && c.tagName !== "BODY") {
						path.push({
							tag: c.tagName,
							id: c.id || null,
							role: c.getAttribute("role"),
							ariaLabel: c.getAttribute("aria-label"),
							classCount: (c.className && typeof c.className === "string") ? c.className.split(" ").length : 0,
						});
						c = c.parentElement;
					}
					return path
				})());
		}
		console.table([...doc.querySelectorAll("[aria-label]")]
			.slice(0, 80)
			.map(el => ({
				tag: el.tagName,
				role: el.getAttribute("role") || "",
				label: el.getAttribute("aria-label"),
			})));
		console.error("[role=row] count:", doc.querySelectorAll("[role=row]").length);
		console.error("[role=grid] count:", doc.querySelectorAll("[role=grid]").length);
		console.error("[role=gridcell] count:", doc.querySelectorAll("[role=gridcell]").length);
		console.error("[contenteditable=true] count:", doc.querySelectorAll("[contenteditable=true]").length);
		// Enumerate every scrollable on the page so we can see why none
		// passed the column-alignment check.
		const allScrollables = [];
		for (const el of doc.querySelectorAll("div")) {
			const s = window.getComputedStyle(el);
			if ((s.overflowY === "auto" || s.overflowY === "scroll") && el.scrollHeight > el.clientHeight) {
				const r = el.getBoundingClientRect();
				allScrollables.push({
					width: Math.round(r.width),
					height: Math.round(r.height),
					left: Math.round(r.left),
					top: Math.round(r.top),
					scrollH: el.scrollHeight,
					ariaLabel: el.getAttribute("aria-label") || "",
				});
			}
		}
		console.error("All scrollable <div>s on the page:");
		console.table(allScrollables);
		return null
	}

	/**
	 * Recursively finds the first scrollable descendant of a given element.
	 *
	 * @param {Element} parent
	 * @param {Window} window
	 * @returns {HTMLDivElement|null}
	 */
	function findScrollableChild(parent, window) {
		for (const child of parent.children) {
			const style = window.getComputedStyle(child);
			if (
				(style.overflowY === "auto" || style.overflowY === "scroll") &&
				child.scrollHeight > child.clientHeight
			) {
				return child
			}
			const found = findScrollableChild(child, window);
			if (found) {
				return found
			}
		}
		return null
	}

	/**
	 * Returns the inner container that holds individual message row divs.
	 *
	 * Strategy ladder:
	 *   1. If the scrollable contains [role=row] elements, return their
	 *      nearest common parent.
	 *   2. Find the deepest descendant whose direct children look like
	 *      message rows (every child is a div, and there are several of
	 *      them — signature of a virtualised message list).
	 *   3. Fall back to the legacy "div with the most children" heuristic.
	 *
	 * @param {Element} scrollable
	 * @returns {HTMLDivElement}
	 */
	function getMessagesInnerContainer(scrollable) {
		const rows = scrollable.querySelectorAll("[role=row]");
		if (rows.length > 0) {
			const parent = rows[0].parentElement;
			if (parent && scrollable.contains(parent)) {
				console.debug("getMessagesInnerContainer: using [role=row] parent,", rows.length, "rows");
				return parent
			}
		}

		// Heuristic: a message-list container has many div-only children,
		// each of which holds visible content (text/img/svg).
		let best = null;
		let bestScore = 0;
		const visit = (el, depth) => {
			if (depth > 6) return
			const children = [...el.children];
			if (children.length >= 3) {
				const divChildren = children.filter(c => c.tagName === "DIV").length;
				const richChildren = children.filter(c =>
					c.querySelector && (c.querySelector("img,svg,video,canvas") || (c.textContent || "").trim().length > 0)
				).length;
				const score = divChildren + richChildren;
				if (divChildren >= 3 && score > bestScore) {
					best = el;
					bestScore = score;
				}
			}
			for (const c of children) visit(c, depth + 1);
		};
		visit(scrollable, 0);
		if (best) {
			console.debug("getMessagesInnerContainer: heuristic container", best, "score", bestScore);
			return best
		}

		// Last resort: the original "div with most children" pick.
		let fallback = scrollable;
		let fallbackCount = scrollable.children.length;
		const search = (el, depth) => {
			if (depth > 3) return
			for (const child of el.children) {
				if (child.children.length > fallbackCount) {
					fallback = child;
					fallbackCount = child.children.length;
				}
				search(child, depth + 1);
			}
		};
		search(scrollable, 0);
		return fallback
	}

	/**
	 * Determines whether a message element was sent by the current user.
	 *
	 * Detection signals, evaluated in order:
	 *   1. Filter out system rows ("Unsupported message", "You unsent a
	 *      message", "Suggested", "Active now", typing indicators, etc.).
	 *   2. If the row contains an "Open the profile page of …" link, it's
	 *      an incoming message → false.
	 *   3. If the bubble's bounding rect right edge is close to the row's
	 *      right edge (and clearly to the right of horizontal centre), the
	 *      bubble is right-aligned → outgoing. This is a layout-driven
	 *      signal that doesn't depend on any aria/role attributes.
	 *   4. Fall back to the legacy `justify-content: flex-end` walk.
	 *
	 * @param {Element} element
	 * @param {Window} window
	 * @returns {boolean}
	 */
	function isSentByCurrentUser(element, window) {
		const text = (element.textContent || "").trim();
		if (!text && !element.querySelector("img,video,canvas,svg")) return false
		if (text.includes("Unsupported message")) return false
		if (text.includes("You unsent a message")) return false

		// Skip system rows that have negligible structure (date dividers,
		// "Active now" banners, typing indicator, etc.).
		const ROW_BLOCKLIST = [
			"Active now",
			"Active ",
			"Seen ",
			"You sent an attachment",
			"sent an attachment",
		];
		for (const phrase of ROW_BLOCKLIST) {
			if (text === phrase || text.startsWith(phrase)) return false
		}

		const profileLink = element.querySelector("a[aria-label^='Open the profile page of'], a[role=link][href^='/']");
		if (profileLink) return false

		// Layout-driven right-alignment: pick the deepest descendant that
		// actually paints (bubble container) and compare its right edge to
		// the row's right edge.
		const rowRect = element.getBoundingClientRect();
		if (rowRect.width > 100) {
			const candidates = element.querySelectorAll("div");
			for (const c of candidates) {
				const r = c.getBoundingClientRect();
				if (r.width < 20 || r.height < 16) continue
				if (r.width > rowRect.width * 0.85) continue
				// Bubble is right-aligned when its right edge hugs the row's
				// right edge AND its left edge sits past the row centre.
				const hugsRight = (rowRect.right - r.right) < 24;
				const pastCentre = r.left > rowRect.left + rowRect.width * 0.35;
				if (hugsRight && pastCentre) {
					return true
				}
			}
		}

		const queue = [{ el: element, depth: 0 }];
		while (queue.length > 0) {
			const { el, depth } = queue.shift();
			const s = window.getComputedStyle(el);
			if (s.justifyContent === "flex-end") {
				return true
			}
			if (depth < 8) {
				for (const child of el.children) {
					queue.push({ el: child, depth: depth + 1 });
				}
			}
		}
		return false
	}

	/**
	 * Gets the first visible message sent by the current user that hasn't been processed yet.
	 *
	 * @param {Element} root - The scrollable messages wrapper
	 * @param {AbortController} abortController
	 * @param {Window} window
	 * @returns {Element|undefined}
	 */
	function getFirstVisibleMessage(root, abortController, window) {
		const innerContainer = getMessagesInnerContainer(root);
		if (!innerContainer) {
			console.debug("getFirstVisibleMessage: no inner container found");
			return
		}

		// Prefer [role=row] children when present, else direct children.
		let candidates = [...innerContainer.querySelectorAll(":scope > [role=row]")];
		if (candidates.length === 0) {
			candidates = [...innerContainer.children];
		}
		console.debug("getFirstVisibleMessage: scanning", candidates.length, "rows");

		// Diagnostic counter so we can see why all candidates were filtered.
		let rejectedNoMarkers = 0;
		let rejectedNotOurs = 0;

		const elements = candidates.filter(d => {
			if (d.hasAttribute("data-idmu-ignore")) return false
			if (d.hasAttribute("data-idmu-unsent")) return false
			// Permissive content check: accept anything with text, an image,
			// or recognised role markers. We DO NOT require a role marker
			// because some IG variants ship rows without role attributes.
			const hasContent =
				d.querySelector("[role=gridcell]") ||
				d.querySelector("[role=none]") ||
				d.querySelector("[role=presentation]") ||
				d.querySelector("img,svg,video,canvas") ||
				(d.textContent || "").trim().length > 0;
			if (!hasContent) {
				rejectedNoMarkers++;
				return false
			}
			if (!isSentByCurrentUser(d, window)) {
				rejectedNotOurs++;
				return false
			}
			return true
		});

		elements.reverse();
		if (elements.length >= 1) {
			console.debug("getFirstVisibleMessage:", elements.length, "candidates after filter",
				"(rejected: empty=" + rejectedNoMarkers + ", incoming/system=" + rejectedNotOurs + ")");
		} else if (candidates.length > 0) {
			console.debug("getFirstVisibleMessage: 0 candidates (rejected: empty=" +
				rejectedNoMarkers + ", incoming/system=" + rejectedNotOurs + ")");
		} else {
			console.debug("getFirstVisibleMessage: 0 candidate rows in inner container");
		}

		for (const element of elements) {
			if (abortController.signal.aborted) {
				console.debug("abortController interupted the message filtering process: stopping...");
				break
			}
			const visibilityCheck = element.checkVisibility({
				visibilityProperty: true,
				contentVisibilityAuto: true,
				opacityProperty: true,
			});
			if (visibilityCheck === false) {
				console.debug("visibilityCheck failed");
				continue
			}
			const rect = element.getBoundingClientRect();
			if (rect.y + rect.height < 0 || rect.height === 0) {
				console.debug("isInView failed", rect.y, rect.height);
				continue
			}
			element.setAttribute("data-idmu-ignore", "");
			console.debug("Message in view, testing workflow...", element);
			return element
		}
	}

	/**
	 * Scrolls to top to trigger loading of older messages.
	 * Handles both normal and column-reverse layouts.
	 *
	 * In column-reverse (Instagram's current layout):
	 *   scrollTop=0 is the BOTTOM (newest messages)
	 *   scrollTop=-(scrollHeight-clientHeight) is the TOP (oldest messages)
	 *
	 * @param {Element} root
	 * @param {AbortController} abortController
	 * @returns {Promise<boolean>}
	 */
	async function loadMoreMessages(root, abortController) {
		console.debug("loadMoreMessages looking for loader... ");
		const scrollAbortController = new AbortController();
		let findLoaderTimeout;
		let resolveTimeout;
		const abortHandler = () => {
			scrollAbortController.abort();
			clearTimeout(findLoaderTimeout);
			if (resolveTimeout) {
				resolveTimeout();
			}
		};
		abortController.signal.addEventListener("abort", abortHandler);

		// Detect column-reverse layout
		const style = root.ownerDocument.defaultView.getComputedStyle(root);
		const isReversed = style.flexDirection === "column-reverse";
		// In column-reverse, "scroll to top" means most negative scrollTop
		const scrollToTopValue = isReversed
			? -(root.scrollHeight - root.clientHeight)
			: 0;
		// In column-reverse, "at top" means scrollTop is at or near minimum
		const isAtTop = () => isReversed
			? root.scrollTop <= scrollToTopValue + 5
			: root.scrollTop === 0;

		const beforeScroll = root.scrollTop;
		const beforeHeight = root.scrollHeight;
		root.scrollTop = scrollToTopValue;

		// Helper: find a visible loader within the scrollable root's viewport
		const findVisibleLoader = () => {
			const bars = root.querySelectorAll("[role=progressbar]");
			for (const bar of bars) {
				const rect = bar.getBoundingClientRect();
				const rootRect = root.getBoundingClientRect();
				// Must be within root's horizontal+vertical bounds and have dimensions
				if (rect.height > 0 && rect.y >= rootRect.y - 100 && rect.y <= rootRect.y + rootRect.height + 100) {
					return bar
				}
			}
			return null
		};

		// Short chat: everything fits in viewport, nothing to load
		const noScrollNeeded = isReversed
			? beforeScroll === 0 && root.scrollHeight <= root.clientHeight + 50
			: beforeScroll === 0 && root.scrollHeight <= root.clientHeight + 50;
		if (noScrollNeeded) {
			console.debug("loadMoreMessages: chat fits in viewport, marking as done");
			abortController.signal.removeEventListener("abort", abortHandler);
			return true
		}

		// Already at top after scrolling: wait briefly for new content, then check
		if (isAtTop()) {
			// Give Instagram a moment to start loading older messages
			await new Promise(resolve => setTimeout(resolve, 500));

			// Check if a visible loader appeared
			const loader = findVisibleLoader();
			if (loader) {
				console.debug("loadMoreMessages: Found visible loader after scroll; waiting for removal (max 5s)");
				await Promise.race([
					waitForElement(root, () => findVisibleLoader() === null, abortController),
					new Promise(resolve => setTimeout(resolve, 5000))
				]);
				abortController.signal.removeEventListener("abort", abortHandler);
				const grew = root.scrollHeight > beforeHeight;
				console.debug(`loadMoreMessages: loader phase done, content ${grew ? "grew" : "did not grow"}`);
				return !grew
			}

			// No loader appeared — check if scrollHeight grew (new content loaded without spinner)
			const grew = root.scrollHeight > beforeHeight;
			if (!grew) {
				console.debug("loadMoreMessages: at top, no loader, no new content — reached last page");
				abortController.signal.removeEventListener("abort", abortHandler);
				return true
			}
		}

		// Fallback: wait for progressbar to appear (with shorter timeout)
		let loadingElement;
		try {
			loadingElement = await Promise.race([
				waitForElement(root, () => {
					if (findVisibleLoader() === null) {
						root.scrollTop = scrollToTopValue;
					}
					return findVisibleLoader()
				}, scrollAbortController),
				new Promise(resolve => {
					resolveTimeout = resolve;
					findLoaderTimeout = setTimeout(() => {
						resolve();
					}, 3000);
				})
			]);
		} catch (ex) {
			console.error(ex);
		}
		scrollAbortController.abort();
		abortController.signal.removeEventListener("abort", abortHandler);
		clearTimeout(findLoaderTimeout);
		if (loadingElement && loadingElement !== true) {
			console.debug("loadMoreMessages: Found loader; Stand-by until it is removed (max 5s)");
			await Promise.race([
				waitForElement(root, () => findVisibleLoader() === null, abortController),
				new Promise(resolve => setTimeout(resolve, 5000))
			]);
		}
		const atTop = isAtTop();
		console.debug(`loadMoreMessages: scrollTop is ${root.scrollTop} — ${atTop ? "reached last page" : "not last page"}`);
		return atTop
	}

	/** @module ui-messages-wrapper UI element representing the messages wrapper */


	class UIMessagesWrapper extends UIComponent {

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise}
		 */
		fetchAndRenderThreadNextMessagePage(abortController) {
			return loadMoreMessages(this.root, abortController)
		}

	}

	/** @module default-ui Default UI / English UI */


	class DefaultUI extends UI {

		constructor(root, identifier = {}) {
			super(root, identifier);
			this.lastScrollTop = null;
		}

		/**
		 * @param {Window} window
		 * @returns {DefaultUI}
		 */
		static create(window) {
			console.debug("UI create: Looking for messagesWrapperElement");
			const messagesWrapperElement = findMessagesWrapper(window);
			if (messagesWrapperElement !== null) {
				console.debug("Found messagesWrapperElement", messagesWrapperElement);
				const uiMessagesWrapper = new UIMessagesWrapper(messagesWrapperElement);
				return new DefaultUI(window, { uiMessagesWrapper })
			} else {
				throw new Error("Unable to find messagesWrapperElement. The query selector might be out of date.")
			}
		}

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise}
		 */
		async fetchAndRenderThreadNextMessagePage(abortController) {
			console.debug("UI fetchAndRenderThreadNextMessagePage");
			return await this.identifier.uiMessagesWrapper.fetchAndRenderThreadNextMessagePage(abortController)
		}

		/**
		 * Scroll until a (visible) message is found and return it.
		 *
		 * Instagram uses flex-direction: column-reverse on the messages container.
		 * This means scrollTop=0 is the BOTTOM (newest messages) and scrolling to
		 * older messages requires NEGATIVE scrollTop values.
		 * In normal (non-reversed) layouts, scrollTop=0 is the top and the max is positive.
		 *
		 * This method detects the layout direction and scrolls accordingly.
		 *
		 * @param {AbortController} abortController
		 * @returns {Promise<UIPIMessage|false>}
		 */
		async getNextUIPIMessage(abortController) {
			console.debug("UI getNextUIPIMessage", this.lastScrollTop);
			const uiMessagesWrapperRoot = this.identifier.uiMessagesWrapper.root;

			const style = this.root.getComputedStyle
				? this.root.getComputedStyle(uiMessagesWrapperRoot)
				: uiMessagesWrapperRoot.ownerDocument.defaultView.getComputedStyle(uiMessagesWrapperRoot);
			const isReversed = style.flexDirection === "column-reverse";

			// Pre-check: try the current scroll position first. After an unsend the DOM
			// shrinks and the next eligible message may already be in viewport without
			// any scrolling needed. This is also the only path that works for short
			// threads where the entire conversation fits on screen.
			try {
				const messageElement = getFirstVisibleMessage(uiMessagesWrapperRoot, abortController, this.root);
				if (messageElement) {
					console.debug("getNextUIPIMessage: found message without scrolling");
					const uiMessage = new UIMessage(messageElement);
					return new UIPIMessage(uiMessage)
				}
			} catch (ex) {
				console.error(ex);
			}

			// Allow up to 3 full passes; covers cases where DOM shrinks after unsends
			for (let pass = 0; pass < 3; pass++) {
				if (abortController.signal.aborted) {
					console.debug("abortController interupted the scrolling: stopping...");
					return false
				}
				if (isReversed) {
					const minScroll = -(uiMessagesWrapperRoot.scrollHeight - uiMessagesWrapperRoot.clientHeight);
					const startPos = (pass === 0 && this.lastScrollTop !== null)
						? Math.max(this.lastScrollTop, minScroll)
						: 0;
					// Use small steps for short conversations to avoid overshooting partially-visible messages.
					const totalRange = Math.abs(minScroll);
					const step = totalRange < 500 ? 30 : 150;
					console.debug(`getNextUIPIMessage [reversed] pass=${pass}, startPos=${startPos}, minScroll=${minScroll}, step=${step}`);

					for (let i = startPos; i >= minScroll; i = i - step) {
						if (abortController.signal.aborted) {
							console.debug("abortController interupted the scrolling: stopping...");
							return false
						}
						this.lastScrollTop = i;
						uiMessagesWrapperRoot.scrollTop = i;
						uiMessagesWrapperRoot.dispatchEvent(new this.root.Event("scroll"));
						await new Promise(resolve => setTimeout(resolve, 5));
						try {
							const messageElement = getFirstVisibleMessage(uiMessagesWrapperRoot, abortController, this.root);
							if (messageElement) {
								const uiMessage = new UIMessage(messageElement);
								return new UIPIMessage(uiMessage)
							}
						} catch (ex) {
							console.error(ex);
						}
					}
				} else {
					const maxScroll = uiMessagesWrapperRoot.scrollHeight - uiMessagesWrapperRoot.clientHeight;
					const startScrollTop = (pass === 0 && this.lastScrollTop !== null)
						? Math.min(this.lastScrollTop, maxScroll)
						: maxScroll;
					const step = maxScroll < 500 ? 30 : 150;
					console.debug(`getNextUIPIMessage pass=${pass}, startScrollTop=${startScrollTop}, maxScroll=${maxScroll}, step=${step}`);

					for (let i = Math.max(1, startScrollTop); i > 0; i = i - step) {
						if (abortController.signal.aborted) {
							console.debug("abortController interupted the scrolling: stopping...");
							return false
						}
						this.lastScrollTop = i;
						uiMessagesWrapperRoot.scrollTop = i;
						uiMessagesWrapperRoot.dispatchEvent(new this.root.Event("scroll"));
						await new Promise(resolve => setTimeout(resolve, 5));
						try {
							const messageElement = getFirstVisibleMessage(uiMessagesWrapperRoot, abortController, this.root);
							if (messageElement) {
								const uiMessage = new UIMessage(messageElement);
								return new UIPIMessage(uiMessage)
							}
						} catch (ex) {
							console.error(ex);
						}
					}
				}

				this.lastScrollTop = null;
				console.debug(`getNextUIPIMessage: pass ${pass} found nothing, retrying`);
			}

			console.debug("getNextUIPIMessage: exhausted all passes, no messages left");
			return false
		}

	}

	/** @module get-ui UI loader module. Allow loading of a certain UI based on a given strategy (locale etc..)
	 * There might be need for multiple UI as Instagram might serve different apps based on location for example.
	 * There is also a need to internationalize each ui so that it doesn't fail if we change the language.
	 */


	/**
	 *
	 * @returns {UI}
	 */
	function getUI() {
		return DefaultUI
	}

	/** @module uipi API for UI */


	/**
	 * UI Interface API
	 */
	class UIPI {

		/**
		 *
		 * @param {UI} ui
		 */
		constructor(ui) {
			this._ui = ui;
		}

		/**
		 *
		 * @param {Window} window
		 * @returns {UIPI}
		 */
		static create(window) {
			console.debug("UIPI.create");
			const ui = getUI().create(window);
			return new UIPI(ui)
		}

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise}
		 */
		fetchAndRenderThreadNextMessagePage(abortController) {
			console.debug("UIPI fetchAndRenderThreadNextMessagePage");
			return this.ui.fetchAndRenderThreadNextMessagePage(abortController)
		}

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise<UIPIMessage>}
		 */
		getNextUIPIMessage(abortController) {
			console.debug("UIPI getNextUIPIMessage");
			return this.ui.getNextUIPIMessage(abortController)
		}

		/**
		 *
		 * @type {UI}
		 */
		get ui() {
			return this._ui
		}

	}

	/** @module idmu Global/Main API for interacting with the UI */


	class IDMU {

		/**
		 *
		 * @param {Window} window
		 * @param {callback} onStatusText
		 */
		constructor(window, onStatusText) {
			this.window = window;
			this.uipi = null;
			this.onStatusText = onStatusText;
		}

		/**
		 * @param {AbortController} abortController
		 * @returns {Promise<UIPIMessage>}
		 */
		getNextUIPIMessage(abortController) {
			return this.uipi.getNextUIPIMessage(abortController)
		}

		/**
		 *
		 * @param {string} text
		 */
		setStatusText(text) {
			this.onStatusText(text);
		}


		/**
		 *
		 * @param {AbortController} abortController
		 * @returns {Promise}
		 */
		fetchAndRenderThreadNextMessagePage(abortController) {
			return this.uipi.fetchAndRenderThreadNextMessagePage(abortController)
		}

		/**
		 * Map Instagram UI
		 */
		loadUIPI() {
			console.debug("loadUIPI");
			this.uipi = UIPI.create(this.window);
		}


	}

	/** @module unsend-strategy Various strategies for unsending messages */


	/**
	 *
	 * @abstract
	 */
	class UnsendStrategy {

		/**
		 *
		 * @param {IDMU} idmu
		 */
		constructor(idmu) {
			this._idmu = idmu;
		}

		/**
		 *
		 * @abstract
		 * @returns {boolean}
		 */
		isRunning() {
		}

		/**
		 *
		 * @abstract
		 */
		stop() {
		}

		/**
		 *
		 * @abstract
		 */
		reset() {
		}

		/**
		 *
		 * @abstract
		 */
		async run() {
		}

		/**
		 * @readonly
		 * @type {IDMU}
		 */
		get idmu() {
			return this._idmu
		}

	}

	/** @module unsend-strategy Various strategies for unsending messages */


	/**
	 * Loads all pages first, then unsends messages from bottom to top.
	 * For short conversations (all messages fit in viewport), skips page loading entirely.
	 */
	class DefaultStrategy extends UnsendStrategy {

		/**
		 * @param {IDMU} idmu
		 */
		constructor(idmu) {
			super(idmu);
			this._allPagesLoaded = false;
			this._unsentCount = 0;
			this._pagesLoadedCount = 0;
			this._running = false;
			this._abortController = null;
			this._lastUnsendDate = null;
			this._consecutiveFailures = 0;
		}

		/**
		 * @returns {boolean}
		 */
		isRunning() {
			return this._running && this._abortController && this._abortController.signal.aborted === false
		}

		stop() {
			console.debug("DefaultStrategy stop");
			this.idmu.setStatusText("Stopping...");
			this._abortController.abort();
		}

		reset() {
			this._allPagesLoaded = false;
			this._unsentCount = 0;
			this._lastUnsendDate = null;
			this._pagesLoadedCount = 0;
			this._consecutiveFailures = 0;
			this.idmu.setStatusText("Ready");
		}

		/**
		 * @returns {Promise}
		 */
		async run() {
			console.debug("DefaultStrategy.run()");
			this._unsentCount = 0;
			this._pagesLoadedCount = 0;
			this._consecutiveFailures = 0;
			this._running = true;
			this._abortController = new AbortController();
			// Clear stale ignore markers from previous runs so messages can be retried
			this.idmu.window.document.querySelectorAll("[data-idmu-ignore]").forEach(el => {
				el.removeAttribute("data-idmu-ignore");
			});
			this.idmu.loadUIPI();
			try {
				if (this._allPagesLoaded) {
					await this.#unsendNextMessage();
				} else {
					await this.#loadNextPage();
				}

				// Race condition: on first page load, Instagram's React may not have
				// finished hydrating message components (role attributes missing).
				// If we found nothing, wait and re-scan up to 3 times.
				if (this._unsentCount === 0 && !this._abortController.signal.aborted) {
					for (let retry = 1; retry <= 3; retry++) {
						this.idmu.setStatusText(`No messages detected, retrying (${retry}/3)...`);
						console.debug(`DefaultStrategy: 0 messages found, retry ${retry}/3`);
						await new Promise(resolve => setTimeout(resolve, 2000));
						if (this._abortController.signal.aborted) break
						// Reset for fresh scan
						this._allPagesLoaded = false;
						this._consecutiveFailures = 0;
						this.idmu.window.document.querySelectorAll("[data-idmu-ignore]").forEach(el => {
							el.removeAttribute("data-idmu-ignore");
						});
						this.idmu.loadUIPI();
						await this.#loadNextPage();
						if (this._unsentCount > 0 || this._abortController.signal.aborted) break
					}
				}

				if (this._abortController.signal.aborted) {
					this.idmu.setStatusText(`Aborted. ${this._unsentCount} message(s) unsent.`);
					console.debug("DefaultStrategy aborted");
				} else {
					this.idmu.setStatusText(`Done. ${this._unsentCount} message(s) unsent.`);
					console.debug("DefaultStrategy done");
				}
			} catch (ex) {
				console.error(ex);
				this.idmu.setStatusText(`Errored. ${this._unsentCount} message(s) unsent.`);
				console.debug("DefaultStrategy errored");
			}
			this._running = false;
		}

		/**
		 * Tries to load the thread next page.
		 * If loadMoreMessages returns true (no more pages), moves to unsending.
		 */
		async #loadNextPage() {
			if (this._abortController.signal.aborted) {
				console.debug("abortController interupted the loading of next page: stopping...");
				return
			}
			this.idmu.setStatusText("Loading next page...");
			try {
				const done = await this.idmu.fetchAndRenderThreadNextMessagePage(this._abortController);
				if (this._abortController.signal.aborted === false) {
					if (done) {
						this.idmu.setStatusText(`All pages loaded (${this._pagesLoadedCount} in total). Unsending...`);
						this._allPagesLoaded = true;
						await this.#unsendNextMessage();
					} else {
						this._pagesLoadedCount++;
						await this.#loadNextPage();
					}
				} else {
					console.debug("abortController interupted the loading of next page: stopping...");
				}
			} catch (ex) {
				console.error(ex);
			}
		}

		/**
		 * Unsend first message in viewport.
		 * Uses human-like randomized delays and exponential backoff to avoid Instagram rate limits.
		 */
		async #unsendNextMessage() {
			if (this._abortController.signal.aborted) {
				console.debug("abortController interupted the unsending of next message: stopping...");
				return
			}
			if (this._consecutiveFailures >= 5) {
				this.idmu.setStatusText(`Stopped: ${this._consecutiveFailures} consecutive failures. ${this._unsentCount} message(s) unsent.`);
				console.debug("DefaultStrategy stopping due to consecutive failures");
				return
			}
			let canScroll = true;
			let msgElement = null;
			try {
				this.idmu.setStatusText(`Retrieving next message... (${this._unsentCount} unsent so far)`);
				const uipiMessage = await this.idmu.getNextUIPIMessage(this._abortController);
				canScroll = uipiMessage !== false;
				if (uipiMessage) {
					this.idmu.setStatusText(`Unsending message... (${this._unsentCount + 1})`);

					// Adaptive baseline delay: 1-2s randomized between unsends.
					// Exponential backoff (below) only kicks in when a rate limit is
					// actually detected, keeping normal-case throughput high.
					if (this._lastUnsendDate !== null) {
						const elapsed = Date.now() - this._lastUnsendDate.getTime();
						const minDelay = 1000 + Math.floor(Math.random() * 1000);
						if (elapsed < minDelay) {
							const waitMs = minDelay - elapsed;
							this.idmu.setStatusText(`Waiting ${(waitMs / 1000).toFixed(1)}s... (${this._unsentCount} unsent so far)`);
							await new Promise(resolve => setTimeout(resolve, waitMs));
						}
					}

					if (this._abortController.signal.aborted) return

					msgElement = uipiMessage.uiMessage.root;
					const unsent = await uipiMessage.unsend(this._abortController);

					if (unsent) {
						// Verify the message actually disappeared from DOM (server accepted the mutation).
						// On a successful unsend, Instagram either removes the row entirely (isConnected=false)
						// or replaces the bubble with a "You unsent a message" placeholder (no [role=gridcell]
						// / [role=presentation] / [role=none] descendants left). On a server-rejected unsend
						// (rate limit), the original bubble snaps back into place.
						await new Promise(resolve => setTimeout(resolve, 800));
						const bubbleStillPresent = msgElement.isConnected && (
							msgElement.querySelector("[role=gridcell]") ||
							msgElement.querySelector("[role=presentation]") ||
							msgElement.querySelector("[role=none]")
						) && !(msgElement.textContent || "").includes("You unsent a message");
						const stillInDOM = !!bubbleStillPresent;
						if (stillInDOM) {
							// Server likely rejected — the message reappeared after optimistic removal
							console.debug("DefaultStrategy: message still in DOM after unsend, possible rate limit");
							msgElement.removeAttribute("data-idmu-ignore");
							this._consecutiveFailures++;
							const backoffMs = Math.min(60000, 5000 * Math.pow(2, this._consecutiveFailures - 1));
							this.idmu.setStatusText(`Server may have rejected unsend. Backing off ${(backoffMs / 1000).toFixed(0)}s... (${this._unsentCount} unsent)`);
							await new Promise(resolve => setTimeout(resolve, backoffMs));
						} else {
							this._lastUnsendDate = new Date();
							this._unsentCount++;
							this._consecutiveFailures = 0;
							// DOM shrunk after removal; reset scroll for fresh scan
							if (this.idmu.uipi && this.idmu.uipi.ui) {
								this.idmu.uipi.ui.lastScrollTop = null;
							}
						}
					} else {
						// Unsend workflow returned false — allow retry on next pass
						console.debug("DefaultStrategy: unsend returned false, removing ignore marker for retry");
						msgElement.removeAttribute("data-idmu-ignore");
						this._consecutiveFailures++;
					}
				}
			} catch (ex) {
				console.error(ex);
				// Remove ignore marker so this message can be retried
				if (msgElement) {
					msgElement.removeAttribute("data-idmu-ignore");
				}
				this._consecutiveFailures++;
				const backoffMs = Math.min(60000, 3000 * Math.pow(2, this._consecutiveFailures - 1));
				this.idmu.setStatusText(`Workflow failed (${this._consecutiveFailures}/5), retrying in ${(backoffMs / 1000).toFixed(0)}s... (${this._unsentCount} unsent)`);
				await new Promise(resolve => setTimeout(resolve, backoffMs));
			} finally {
				if (canScroll && this._abortController && !this._abortController.signal.aborted) {
					await this.#unsendNextMessage();
				}
			}
		}

	}

	/** @module alert Alert UI */

	/**
	 *
	 * @param {Document} document
	 * @returns {HTMLButtonElement}
	 */
	function createAlertsWrapperElement(document) {
		const alertsWrapperElement = document.createElement("div");
		alertsWrapperElement.id = "idmu-alerts";
		alertsWrapperElement.style.position = "fixed";
		alertsWrapperElement.style.top = "20px";
		alertsWrapperElement.style.right = "20px";
		alertsWrapperElement.style.display = "grid";
		return alertsWrapperElement
	}

	/** @module overlay IDMU's overlay */

	/**
	 * @param {Document} document
	 * @returns {HTMLDivElement}
	 */
	function createOverlayElement(document) {
		const overlayElement = document.createElement("div");
		overlayElement.id = "idmu-overlay";
		overlayElement.tabIndex = 0;
		overlayElement.style.top = "0";
		overlayElement.style.right = "0";
		overlayElement.style.position = "fixed";
		overlayElement.style.width = "100vw";
		overlayElement.style.height = "100vh";
		overlayElement.style.zIndex = "998";
		overlayElement.style.backgroundColor = "#000000d6";
		overlayElement.style.display = "none";
		return overlayElement
	}

	/** @module ui IDMU's own ui/overlay
	 * Provide a button to unsend messages
	 */


	class OSD {
		/**
		 *
		 * @param {Document} document
		 * @param {HTMLDivElement} root
		 * @param {HTMLDivElement} overlayElement
		 * @param {HTMLDivElement} menuElement
		 * @param {HTMLButtonElement} unsendThreadMessagesButton
		 * @param {HTMLDivElement} statusElement
		 */
		constructor(document, root, overlayElement, menuElement, unsendThreadMessagesButton, statusElement) {
			this._document = document;
			this._root = root;
			this._overlayElement = overlayElement;
			this._menuElement = menuElement;
			this._statusElement = statusElement;
			this._unsendThreadMessagesButton = unsendThreadMessagesButton;
			this._idmu = new IDMU(this.window, this.onStatusText.bind(this));
			this._strategy = new DefaultStrategy(this._idmu); // TODO move out
		}

		/**
		 *
		 * @param {window} window
		 * @returns {OSD}
		 */
		static render(window) {
			console.debug("render");
			const ui = OSD.create(window.document);
			window.document.body.appendChild(ui.root);
			return ui
		}

		/**
		 *
		 * @param   {Document} document
		 * @returns {OSD}
		 */
		static create(document) {
			const root = document.createElement("div");
			root.id = "idmu-root";
			const menuElement = createMenuElement(document);
			const overlayElement = createOverlayElement(document);
			const alertsWrapperElement = createAlertsWrapperElement(document);
			const unsendThreadMessagesButton = createMenuButtonElement(document, "Unsend all DMs", BUTTON_STYLE.PRIMARY);
			const statusElement = document.createElement("div");
			statusElement.textContent = "Ready";
			statusElement.id = "idmu-status";
			statusElement.style = "width: 200px";
			document.body.appendChild(overlayElement);
			document.body.appendChild(alertsWrapperElement);
			menuElement.appendChild(unsendThreadMessagesButton);
			menuElement.appendChild(statusElement);
			root.appendChild(menuElement);
			const ui = new OSD(document, root, overlayElement, menuElement, unsendThreadMessagesButton, statusElement);
			document.addEventListener("keydown", (event) => ui.#onWindowKeyEvent(event)); // TODO test
			document.addEventListener("keyup", (event) => ui.#onWindowKeyEvent(event)); // TODO test
			unsendThreadMessagesButton.addEventListener("click", (event) => ui.#onUnsendThreadMessagesButtonClick(event));
			ui._mutationObserver = new MutationObserver((mutations) => ui.#onMutations(ui, mutations));
			ui._mutationObserver.observe(document.body, { childList: true }); // TODO test
			unsendThreadMessagesButton.dataTextContent = unsendThreadMessagesButton.textContent;
			unsendThreadMessagesButton.dataBackgroundColor = unsendThreadMessagesButton.style.backgroundColor;
			return ui
		}

		/**
		 *
		 * @param {string} text
		 */
		onStatusText(text) {
			this.statusElement.textContent = text;
		}

		async #startUnsending() {
	[...this.menuElement.querySelectorAll("button")].filter(button => button !== this.unsendThreadMessagesButton).forEach(button => {
				button.style.visibility = "hidden";
				button.disabled = true;
			});
			this.overlayElement.style.display = "";
			this.overlayElement.focus();
			this.unsendThreadMessagesButton.textContent = "Stop processing";
			this.unsendThreadMessagesButton.style.backgroundColor = "#FA383E";
			this.statusElement.style.color = "white";
			this._mutationObserver.disconnect();
			try {
				await this.strategy.run();
			} catch(error) {
				console.error(error);
				if(this.strategy.isRunning()) {
					this.strategy.stop();
				}
				this.statusElement.innerHTML = `<span style="color: red">An error occured, <a href="https://github.com/thoughtsunificator/instagram-dm-unsender/issues/new?template=bug_report.md">please open an issue</a></span>`;
			} finally {
				this.#onUnsendingFinished();
			}
		}

		/**
		 *
		 * @param {OSD} ui
		 */
		#onMutations(ui) {
			if(ui.root.ownerDocument.querySelector("[id^=mount] > div > div > div") !== null && ui) {
				if(this._mutationObserver) {
					this._mutationObserver.disconnect();
				}
				this._mutationObserver = new MutationObserver(ui.#onMutations.bind(this, ui));
				this._mutationObserver.observe(ui.root.ownerDocument.querySelector("[id^=mount] > div > div > div"), { childList: true, attributes: true });
			}
			if(this.window.location.pathname.startsWith("/direct/t/")) {
				if(!this.strategy.isRunning()) {
					this.strategy.reset();
				}
				this.root.style.display = "";
			} else {
				this.root.style.display = "none";
				if(this.strategy.isRunning()) {
					this.strategy.stop();
				}
			}
		}

		/**
		 *
		 * @param {OSD} ui
		 * @param {Event} event
		 */
		#onUnsendThreadMessagesButtonClick() {
			if(this.strategy.isRunning()) {
				console.debug("User asked for messages unsending to stop");
				this.strategy.stop();
				this.#onUnsendingFinished();
			} else {
				console.debug("User asked for messages unsending to start; UI interaction will be disabled in the meantime");
				this.#startUnsending();
			}
		}

		/**
		 *
		 * @param {Event} event
		 * @returns {boolean}
		 */
		#onWindowKeyEvent(event) {
			if(this.strategy.isRunning()) {
				console.log("User interaction is disabled as the unsending is still running; Please stop the execution first.");
				event.stopImmediatePropagation();
				event.preventDefault();
				event.stopPropagation();
				this.overlayElement.focus();
				return false
			}
		}

		#onUnsendingFinished() {
			console.debug("render onUnsendingFinished")
			;[...this.menuElement.querySelectorAll("button")].filter(button => button !== this.unsendThreadMessagesButton).forEach(button => {
				button.style.visibility = "";
				button.disabled = false;
			});
			this.unsendThreadMessagesButton.textContent = this.unsendThreadMessagesButton.dataTextContent;
			this.unsendThreadMessagesButton.style.backgroundColor = this.unsendThreadMessagesButton.dataBackgroundColor;
			this.overlayElement.style.display = "none";
			this.statusElement.style.color = "";
			this._mutationObserver.observe(this._document.body, { childList: true }); // TODO test
		}

		/**
		 * @readonly
		 * @type {Document}
		 */
		get document() {
			return this._document
		}

		/**
		 * @readonly
		 * @type {Window}
		 */
		get window() {
			return this._document.defaultView
		}

		/**
		 * @readonly
		 * @type {HTMLDivElement}
		 */
		get root() {
			return this._root
		}

		/**
		 * @readonly
		 * @type {HTMLDivElement}
		 */
		get overlayElement() {
			return this._overlayElement
		}

		/**
		 * @readonly
		 * @type {HTMLDivElement}
		 */
		get menuElement() {
			return this._menuElement
		}

		/**
		 * @readonly
		 * @type {HTMLButtonElement}
		 */
		get unsendThreadMessagesButton() {
			return this._unsendThreadMessagesButton
		}

		/**
		 * @readonly
		 * @type {HTMLDivElement}
		 */
		get statusElement() {
			return this._statusElement
		}

		/**
		 * @readonly
		 * @type {UnsendStrategy}
		 */
		get strategy() { // TODO move out
			return this._strategy
		}

		/**
		 * @readonly
		 * @type {IDMU}
		 */
		get idmu() {
			return this._idmu
		}

	}

	/** @module main Main module */


	/**
	 * @param {Window} window
	 */
	function main(window) {
		OSD.render(window);
	}

	if(typeof window !== "undefined") {
		main(window);
	}

	exports.main = main;

	return exports;

})({});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"idmu.user.js","sources":["../src/runtime/userscript/osd/style/instagram.js","../src/runtime/userscript/osd/menu-button.js","../src/runtime/userscript/osd/menu.js","../src/dom/async-events.js","../src/ui/ui-component.js","../src/ui/default/ui-message.js","../src/uipi/uipi-message.js","../src/ui/ui.js","../src/ui/default/dom-lookup.js","../src/ui/default/ui-messages-wrapper.js","../src/ui/default/default-ui.js","../src/ui/get-ui.js","../src/uipi/uipi.js","../src/idmu/idmu.js","../src/ui/unsend-strategy.js","../src/ui/default/unsend-strategy.js","../src/runtime/userscript/osd/alert.js","../src/runtime/userscript/osd/overlay.js","../src/runtime/userscript/osd/osd.js","../src/runtime/userscript/main.js"],"sourcesContent":["/** @module instagram Helpers to mimick Instagram's look and feel */\n\nexport const BUTTON_STYLE = {\n\t\"PRIMARY\": \"primary\",\n\t\"SECONDARY\": \"secondary\",\n}\n\n/**\n *\n * @param {HTMLButtonElement} buttonElement\n * @param {string}            styleName\n */\nexport function applyButtonStyle(buttonElement, styleName) {\n\tbuttonElement.style.fontSize = \"var(--system-14-font-size)\"\n\tbuttonElement.style.color = \"white\"\n\tbuttonElement.style.border = \"0px\"\n\tbuttonElement.style.borderRadius = \"8px\"\n\tbuttonElement.style.padding = \"8px\"\n\tbuttonElement.style.fontWeight = \"bold\"\n\tbuttonElement.style.cursor = \"pointer\"\n\tbuttonElement.style.lineHeight = \"var(--system-14-line-height)\"\n\tif(styleName) {\n\t\tbuttonElement.style.backgroundColor = `rgb(var(--ig-${styleName}-button))`\n\t}\n}\n","/** @module menu-button Helpers to create buttons that can be used in IDMU's menu */\n\nimport { applyButtonStyle } from \"./style/instagram.js\"\n\n/**\n *\n * @param {Document} document\n * @param {string}   text\n * @param {string}   styleName\n * @returns {HTMLButtonElement}\n */\nexport function createMenuButtonElement(document, text, styleName) {\n\tconst buttonElement = document.createElement(\"button\")\n\tbuttonElement.textContent = text\n\tapplyButtonStyle(buttonElement, styleName)\n\tbuttonElement.addEventListener(\"mouseover\", () => {\n\t\tbuttonElement.style.filter = `brightness(1.15)`\n\t})\n\tbuttonElement.addEventListener(\"mouseout\", () => {\n\t\tbuttonElement.style.filter = ``\n\t})\n\treturn buttonElement\n}\n","/** @module menu IDMU's main menu */\n\n/**\n * @param {Document} document\n * @returns {HTMLButtonElement}\n */\nexport function createMenuElement(document) {\n\tconst menuElement = document.createElement(\"div\")\n\tmenuElement.id = \"idmu-menu\"\n\tmenuElement.style.top = \"20px\"\n\tmenuElement.style.right = \"430px\"\n\tmenuElement.style.position = \"fixed\"\n\tmenuElement.style.zIndex = 999\n\tmenuElement.style.display = \"flex\"\n\tmenuElement.style.gap = \"10px\"\n\tmenuElement.style.placeItems = \"center\"\n\treturn menuElement\n}\n","/** @module async-events Utils module for finding elements asynchronously in the DOM */\n\n/**\n *\n * @callback getElement\n * @returns {Element}\n */\n\n/**\n *\n * @param {Element} target\n * @param {getElement} getElement\n * @param {AbortController} abortController\n * @returns {Promise<Element>}\n */\nexport function waitForElement(target, getElement, abortController) {\n\treturn new Promise((resolve, reject) => {\n\t\tlet mutationObserver\n\t\tconst abortHandler = () => {\n\t\t\tif(mutationObserver) {\n\t\t\t\treject(new DOMException(\"Aborted: Disconnecting mutation observer...\", \"AbortError\"))\n\t\t\t\tmutationObserver.disconnect()\n\t\t\t} else {\n\t\t\t\treject(new DOMException(\"Aborted\", \"AbortError\"))\n\t\t\t}\n\t\t}\n\t\tabortController.signal.addEventListener(\"abort\", abortHandler)\n\t\tlet element = getElement()\n\t\tif(element) {\n\t\t\tresolve(element)\n\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t} else {\n\t\t\tmutationObserver = new MutationObserver((mutations, observer) => {\n\t\t\t\telement = getElement(mutations)\n\t\t\t\tif(element) {\n\t\t\t\t\tobserver.disconnect()\n\t\t\t\t\tresolve(element)\n\t\t\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t\t\t}\n\t\t\t})\n\t\t\tmutationObserver.observe(target, { subtree: true, childList:true })\n\t\t}\n\t})\n}\n\n/**\n *\n * @param {Element} clickTarget\n * @param {Element} target\n * @param {getElement} getElement\n * @param {AbortController} abortController\n * @returns {Element|Promise<Element>}\n */\nexport function clickElementAndWaitFor(clickTarget, target, getElement, abortController) {\n\tconst promise = waitForElement(target, getElement, abortController)\n\tclickTarget.click()\n\treturn getElement() || promise\n}\n","/** @module ui-component Base class for any element that is a part of the UI. */\n\nimport { waitForElement, clickElementAndWaitFor } from \"../dom/async-events.js\"\n\n/**\n *\n * @abstract\n */\nclass UIComponent {\n\t/**\n\t *\n\t * @param {Element} root\n\t * @param {object} identifier\n\t */\n\tconstructor(root, identifier={}) {\n\t\tthis.root = root\n\t\tthis.identifier = identifier\n\t}\n\n\t/**\n\t *\n\t * @param {Element} target\n\t * @param {function} getElement\n\t * @param {AbortController} abortController\n\t * @returns {Promise<Element>}\n\t */\n\twaitForElement(target, getElement, abortController) {\n\t\treturn getElement() || waitForElement(target, getElement, abortController)\n\t}\n\n\t/**\n\t *\n\t * @param {Element} clickTarget\n\t * @param {Element} target\n\t * @param {function} getElement\n\t * @param {AbortController} abortController\n\t * @returns {Promise<Element>}\n\t */\n\tclickElementAndWaitFor(clickTarget, target, getElement, abortController) {\n\t\treturn clickElementAndWaitFor(clickTarget, target, getElement, abortController)\n\t}\n\n}\n\nexport default UIComponent\n","/** @module ui-message UI element representing a message */\n\nimport UIComponent from \"../ui-component.js\"\n\n/** Locale-independent patterns for the \"Unsend\" menu item */\nconst UNSEND_TEXT_VARIANTS = [\n\t\"unsend\",        // English\n\t\"annulla invio\", // Italian\n\t\"retirar\",       // Portuguese\n\t\"deshacer\",      // Spanish\n\t\"retirer\",       // French\n\t\"zurücknehmen\",  // German\n]\n\n/**\n * Dispatches pointer and mouse hover events on a target element.\n * Instagram's React uses pointer events internally; mouse events alone are insufficient.\n *\n * @param {Element} target\n */\nfunction dispatchHoverIn(target) {\n\tconst rect = target.getBoundingClientRect()\n\tconst opts = {\n\t\tbubbles: true,\n\t\tcancelable: true,\n\t\tclientX: rect.x + rect.width / 2,\n\t\tclientY: rect.y + rect.height / 2,\n\t\tpointerId: 1,\n\t\tpointerType: \"mouse\",\n\t}\n\ttarget.dispatchEvent(new PointerEvent(\"pointerenter\", { ...opts, bubbles: false }))\n\ttarget.dispatchEvent(new PointerEvent(\"pointerover\", opts))\n\ttarget.dispatchEvent(new PointerEvent(\"pointermove\", opts))\n\ttarget.dispatchEvent(new MouseEvent(\"mouseenter\", { ...opts, bubbles: false }))\n\ttarget.dispatchEvent(new MouseEvent(\"mouseover\", opts))\n\ttarget.dispatchEvent(new MouseEvent(\"mousemove\", opts))\n}\n\n/**\n * Dispatches pointer and mouse leave events on a target element.\n *\n * @param {Element} target\n */\nfunction dispatchHoverOut(target) {\n\tconst rect = target.getBoundingClientRect()\n\tconst opts = {\n\t\tbubbles: true,\n\t\tcancelable: true,\n\t\tclientX: rect.x + rect.width / 2,\n\t\tclientY: rect.y + rect.height / 2,\n\t\tpointerId: 1,\n\t\tpointerType: \"mouse\",\n\t}\n\ttarget.dispatchEvent(new PointerEvent(\"pointerout\", opts))\n\ttarget.dispatchEvent(new PointerEvent(\"pointerleave\", { ...opts, bubbles: false }))\n\ttarget.dispatchEvent(new MouseEvent(\"mouseout\", opts))\n\ttarget.dispatchEvent(new MouseEvent(\"mouseleave\", { ...opts, bubbles: false }))\n}\n\nclass UIMessage extends UIComponent {\n\n\t/**\n\t * Dismiss any stale dialog or dropdown left from a previous failed workflow.\n\t */\n\t_dismissStaleOverlays() {\n\t\tconst doc = this.root.ownerDocument\n\t\t// Close stale confirmation dialogs\n\t\tconst staleDialog = doc.querySelector(\"[role=dialog]\")\n\t\tif (staleDialog) {\n\t\t\tconsole.debug(\"Dismissing stale dialog\")\n\t\t\tconst closeBtn = staleDialog.querySelector(\"button\")\n\t\t\tif (closeBtn) closeBtn.click()\n\t\t}\n\t\t// Close stale dropdown menus by pressing Escape\n\t\tconst activeMenu = doc.querySelector(\"[role=menu], [role=listbox]\")\n\t\tif (activeMenu) {\n\t\t\tconsole.debug(\"Dismissing stale menu via Escape\")\n\t\t\tdoc.body.dispatchEvent(new KeyboardEvent(\"keydown\", { key: \"Escape\", bubbles: true }))\n\t\t}\n\t}\n\n\t/**\n\t * Find the action button within the message row.\n\t * Instagram moved aria-label from the button div to a nested SVG/title.\n\t * Any match (SVG or div) is walked up to the nearest [role=button] ancestor.\n\t *\n\t * @param {Element} scope\n\t * @returns {Element|null}\n\t */\n\t_findActionButton(scope) {\n\t\tconst LABEL_PATTERNS = [\n\t\t\t\"[aria-label^='See more options for message']\",\n\t\t\t\"[aria-label*='more options']\",\n\t\t\t\"[aria-label*='More']\",\n\t\t\t\"[aria-label*='Altre opzioni']\",\n\t\t\t\"[aria-label*='opzioni']\",\n\t\t\t\"[aria-label*='opciones']\",\n\t\t\t\"[aria-label*='options']\",\n\t\t]\n\n\t\tfor (const sel of LABEL_PATTERNS) {\n\t\t\tconst el = scope.querySelector(sel)\n\t\t\tif (el) {\n\t\t\t\t// Always resolve to a clickable button container\n\t\t\t\tconst btn = el.closest(\"[role=button]\") || el.closest(\"button\")\n\t\t\t\tif (btn && scope.contains(btn)) return btn\n\t\t\t\t// el itself is already a button-like element\n\t\t\t\tif (el.tagName === \"BUTTON\" || el.getAttribute(\"role\") === \"button\") return el\n\t\t\t}\n\t\t}\n\n\t\t// Fallback: any role=button with aria-haspopup=menu inside the message row\n\t\treturn scope.querySelector(\"[role=button][aria-haspopup=menu]\")\n\t}\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise<HTMLButtonElement>}\n\t */\n\tasync showActionsMenuButton(abortController) {\n\t\tconsole.debug(\"Workflow step 1 : showActionsMenuButton\", this.root)\n\t\tthis._dismissStaleOverlays()\n\n\t\t// Collect all hoverable ancestors from root down to the message bubble.\n\t\t// Instagram React listens at intermediate levels (role=group, flex-end wrapper).\n\t\tconst hoverTargets = [this.root]\n\t\tconst collectTargets = (el, depth) => {\n\t\t\tif (depth > 8) return\n\t\t\tfor (const child of el.children) {\n\t\t\t\thoverTargets.push(child)\n\t\t\t\tcollectTargets(child, depth + 1)\n\t\t\t}\n\t\t}\n\t\tcollectTargets(this.root, 0)\n\n\t\t// Try up to 3 times — hover events can be flaky\n\t\tfor (let attempt = 0; attempt < 3; attempt++) {\n\t\t\tif (abortController.signal.aborted) return null\n\n\t\t\tfor (const target of hoverTargets) {\n\t\t\t\tdispatchHoverIn(target)\n\t\t\t}\n\n\t\t\tawait new Promise(resolve => setTimeout(resolve, 100))\n\n\t\t\tconst btn = this._findActionButton(this.root)\n\t\t\tif (btn) {\n\t\t\t\tconsole.debug(\"Workflow step 1 : found action button on attempt\", attempt, btn)\n\t\t\t\treturn btn\n\t\t\t}\n\n\t\t\tconsole.debug(\"Workflow step 1 : attempt\", attempt, \"no button found, retrying...\")\n\t\t\tdispatchHoverOut(this.root)\n\t\t\tawait new Promise(resolve => setTimeout(resolve, 50))\n\t\t}\n\n\t\t// Final fallback: use waitForElement with extended timeout\n\t\tconst waitAbortController = new AbortController()\n\t\tlet promiseTimeout\n\t\tconst abortHandler = () => {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t}\n\t\tabortController.signal.addEventListener(\"abort\", abortHandler)\n\n\t\tfor (const target of hoverTargets) {\n\t\t\tdispatchHoverIn(target)\n\t\t}\n\n\t\ttry {\n\t\t\tconst actionButton = await Promise.race([\n\t\t\t\tthis.waitForElement(\n\t\t\t\t\tthis.root,\n\t\t\t\t\t() => this._findActionButton(this.root),\n\t\t\t\t\twaitAbortController\n\t\t\t\t),\n\t\t\t\tnew Promise((resolve, reject) => {\n\t\t\t\t\tpromiseTimeout = setTimeout(() => reject(\"Timeout showActionsMenuButton\"), 3000)\n\t\t\t\t})\n\t\t\t])\n\n\t\t\tif (actionButton) {\n\t\t\t\treturn actionButton\n\t\t\t}\n\t\t\treturn actionButton\n\t\t} finally {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t}\n\t}\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise<boolean>}\n\t */\n\tasync hideActionMenuButton(abortController) {\n\t\tconsole.debug(\"hideActionMenuButton\", this.root)\n\t\tdispatchHoverOut(this.root)\n\n\t\tconst noneEl = this.root.querySelector(\"[role=none]\")\n\t\tif (noneEl) {\n\t\t\tdispatchHoverOut(noneEl)\n\t\t}\n\n\t\tconst waitAbortController = new AbortController()\n\t\tlet promiseTimeout\n\t\tlet resolveTimeout\n\t\tconst abortHandler = () => {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t\tif (resolveTimeout) {\n\t\t\t\tresolveTimeout()\n\t\t\t}\n\t\t}\n\t\tabortController.signal.addEventListener(\"abort\", abortHandler)\n\n\t\ttry {\n\t\t\tconst result = await Promise.race([\n\t\t\t\tthis.waitForElement(\n\t\t\t\t\tthis.root,\n\t\t\t\t\t() => this._findActionButton(this.root) === null,\n\t\t\t\t\twaitAbortController\n\t\t\t\t),\n\t\t\t\tnew Promise((resolve, reject) => {\n\t\t\t\t\tresolveTimeout = resolve\n\t\t\t\t\tpromiseTimeout = setTimeout(() => reject(\"Timeout hideActionMenuButton\"), 500)\n\t\t\t\t})\n\t\t\t])\n\t\t\treturn result\n\t\t} finally {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t}\n\t}\n\n\t/**\n\t * Opens the actions menu by clicking the action button and waiting for the \"Unsend\" item.\n\t *\n\t * @param {HTMLButtonElement} actionButton\n\t * @param {AbortController} abortController\n\t * @returns {Promise}\n\t */\n\tasync openActionsMenu(actionButton, abortController) {\n\t\tconsole.debug(\"Workflow step 2 : Clicking actionButton and waiting for unsend menu item to appear\", actionButton)\n\t\tconst waitAbortController = new AbortController()\n\t\tlet promiseTimeout\n\t\tlet resolveTimeout\n\t\tconst abortHandler = () => {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t\tif (resolveTimeout) {\n\t\t\t\tresolveTimeout()\n\t\t\t}\n\t\t}\n\t\tabortController.signal.addEventListener(\"abort\", abortHandler)\n\n\t\t/** Check if text matches any known \"Unsend\" variant */\n\t\tconst isUnsendText = (text) => {\n\t\t\tconst normalized = text.trim().toLocaleLowerCase()\n\t\t\treturn UNSEND_TEXT_VARIANTS.some(v => normalized === v)\n\t\t}\n\n\t\ttry {\n\t\t\tconst unsendButton = await Promise.race([\n\t\t\t\tthis.clickElementAndWaitFor(\n\t\t\t\t\tactionButton,\n\t\t\t\t\tthis.root.ownerDocument.body,\n\t\t\t\t\t(mutations) => {\n\t\t\t\t\t\tif (mutations) {\n\t\t\t\t\t\t\tconst addedNodes = [...mutations.map(mutation => [...mutation.addedNodes])].flat().filter(node => node.nodeType === 1)\n\t\t\t\t\t\t\tfor (const addedNode of addedNodes) {\n\t\t\t\t\t\t\t\tconst node = [...addedNode.querySelectorAll(\"span,div\")].find(node => isUnsendText(node.textContent) && node.firstChild?.nodeType === 3)\n\t\t\t\t\t\t\t\tif (node) {\n\t\t\t\t\t\t\t\t\tconsole.debug(\"Workflow step 2 : found unsend node via mutation\", node)\n\t\t\t\t\t\t\t\t\treturn node\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Fallback: scan the whole document for an unsend menu item already present\n\t\t\t\t\t\tconst allSpans = this.root.ownerDocument.querySelectorAll(\"[role=menu] span, [role=menu] div, [role=menuitem] span, [role=menuitem] div\")\n\t\t\t\t\t\tfor (const span of allSpans) {\n\t\t\t\t\t\t\tif (isUnsendText(span.textContent) && span.firstChild?.nodeType === 3) {\n\t\t\t\t\t\t\t\tconsole.debug(\"Workflow step 2 : found unsend node via document scan\", span)\n\t\t\t\t\t\t\t\treturn span\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\twaitAbortController\n\t\t\t\t),\n\t\t\t\tnew Promise((resolve, reject) => {\n\t\t\t\t\tpromiseTimeout = setTimeout(() => reject(\"Timeout openActionsMenu\"), 3000)\n\t\t\t\t})\n\t\t\t])\n\n\t\t\tconsole.debug(\"Workflow step 2 : Found unsendButton\", unsendButton)\n\t\t\treturn unsendButton\n\t\t} finally {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t}\n\t}\n\n\t/**\n\t * Closes the actions menu.\n\t *\n\t * @param {HTMLButtonElement} actionButton\n\t * @param {HTMLDivElement} actionsMenuElement\n\t * @param {AbortController} abortController\n\t * @returns {Promise<boolean>}\n\t */\n\tasync closeActionsMenu(actionButton, actionsMenuElement, abortController) {\n\t\tconsole.debug(\"closeActionsMenu\")\n\t\tconst waitAbortController = new AbortController()\n\t\tlet promiseTimeout\n\t\tlet resolveTimeout\n\t\tconst abortHandler = () => {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t\tif (resolveTimeout) {\n\t\t\t\tresolveTimeout()\n\t\t\t}\n\t\t}\n\t\tabortController.signal.addEventListener(\"abort\", abortHandler)\n\n\t\ttry {\n\t\t\tconst result = await Promise.race([\n\t\t\t\tthis.clickElementAndWaitFor(\n\t\t\t\t\tactionButton,\n\t\t\t\t\tthis.root.ownerDocument.body,\n\t\t\t\t\t() => this.root.ownerDocument.body.contains(actionsMenuElement) === false,\n\t\t\t\t\tabortController\n\t\t\t\t),\n\t\t\t\tnew Promise((resolve, reject) => {\n\t\t\t\t\tpromiseTimeout = setTimeout(() => reject(\"Timeout closeActionsMenu\"), 500)\n\t\t\t\t})\n\t\t\t])\n\t\t\treturn result !== null\n\t\t} finally {\n\t\t\twaitAbortController.abort()\n\t\t\tclearTimeout(promiseTimeout)\n\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t}\n\t}\n\n\t/**\n\t * Click unsend button and wait for the confirmation dialog.\n\t *\n\t * @param {HTMLSpanElement} unsendButton\n\t * @param {AbortController} abortController\n\t * @returns {Promise<HTMLButtonElement>|Promise<Error>}\n\t */\n\topenConfirmUnsendModal(unsendButton, abortController) {\n\t\tconsole.debug(\"Workflow step 3 : Clicking unsendButton and waiting for dialog to appear...\")\n\t\treturn this.clickElementAndWaitFor(\n\t\t\tunsendButton,\n\t\t\tthis.root.ownerDocument.body,\n\t\t\t() => this.root.ownerDocument.querySelector(\"[role=dialog] button\"),\n\t\t\tabortController\n\t\t)\n\t}\n\n\t/**\n\t * Click unsend confirm button in the modal dialog.\n\t *\n\t * @param {HTMLButtonElement} dialogButton\n\t * @param {AbortController} abortController\n\t * @returns {Promise}\n\t */\n\tasync confirmUnsend(dialogButton, abortController) {\n\t\tconsole.debug(\"Workflow final step : confirmUnsend\", dialogButton)\n\t\tawait this.clickElementAndWaitFor(\n\t\t\tdialogButton,\n\t\t\tthis.root.ownerDocument.body,\n\t\t\t() => this.root.ownerDocument.querySelector(\"[role=dialog] button\") === null,\n\t\t\tabortController\n\t\t)\n\t}\n\n}\n\nexport default UIMessage\n","/** @module uipi-message API for UIMessage */\n\n/* eslint-disable-next-line no-unused-vars */\nimport UIMessage from \"../ui/default/ui-message.js\"\n\nclass FailedWorkflowException extends Error {}\n\nclass UIPIMessage {\n\n\t/**\n\t * @param {UIMessage} uiMessage\n\t */\n\tconstructor(uiMessage) {\n\t\tthis._uiMessage = uiMessage\n\t}\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise<boolean>}\n\t */\n\tasync unsend(abortController) {\n\t\tconsole.debug(\"UIPIMessage unsend\")\n\t\tlet actionButton\n\t\tlet unsendButton\n\t\ttry {\n\t\t\tactionButton = await this.uiMessage.showActionsMenuButton(abortController)\n\t\t\tunsendButton = await this.uiMessage.openActionsMenu(actionButton, abortController)\n\t\t\tconsole.debug(\"unsendButton\", unsendButton)\n\t\t\tconst dialogButton = await this.uiMessage.openConfirmUnsendModal(unsendButton, abortController)\n\t\t\tawait this.uiMessage.confirmUnsend(dialogButton, abortController)\n\t\t\tthis.uiMessage.root.setAttribute(\"data-idmu-unsent\", \"\")\n\t\t\treturn true\n\t\t} catch(ex) {\n\t\t\tconsole.error(ex)\n\t\t\tthis.uiMessage.root.setAttribute(\"data-idmu-ignore\", \"\")\n\t\t\t// Dismiss any open overlay so the next message starts clean\n\t\t\ttry {\n\t\t\t\tconst doc = this.uiMessage.root.ownerDocument\n\t\t\t\tdoc.body.dispatchEvent(new KeyboardEvent(\"keydown\", { key: \"Escape\", bubbles: true }))\n\t\t\t\tawait new Promise(resolve => setTimeout(resolve, 200))\n\t\t\t\t// If dialog is still open, press Escape again\n\t\t\t\tif (doc.querySelector(\"[role=dialog]\")) {\n\t\t\t\t\tdoc.body.dispatchEvent(new KeyboardEvent(\"keydown\", { key: \"Escape\", bubbles: true }))\n\t\t\t\t\tawait new Promise(resolve => setTimeout(resolve, 200))\n\t\t\t\t}\n\t\t\t} catch (_) { /* best-effort cleanup */ }\n\t\t\tthrow new FailedWorkflowException(\"Failed to execute workflow for this message\", ex)\n\t\t}\n\t}\n\n\t/**\n\t * @type {UIMessage}\n\t */\n\tget uiMessage() {\n\t\treturn this._uiMessage\n\t}\n\n}\nexport { FailedWorkflowException }\nexport default UIPIMessage\n","import UIComponent from \"./ui-component.js\"\n\n/* eslint-disable-next-line no-unused-vars */\nimport UIPIMessage from \"../uipi/uipi-message.js\"\n\n/**\n *\n * @abstract\n */\nclass UI extends UIComponent {\n\n\t/**\n\t *\n\t * @abstract\n\t * @returns {UI}\n\t */\n\tstatic create() {\n\t}\n\n\t/**\n\t *\n\t * @abstract\n\t * @param {AbortController} abortController\n\t * @returns {Promise}\n\t */\n\t/* eslint-disable-next-line no-unused-vars */\n\tasync fetchAndRenderThreadNextMessagePage(abortController) {\n\t}\n\n\t/**\n\t *\n\t * @abstract\n\t * @returns {Promise<UIPIMessage>}\n\t */\n\tasync getNextUIPIMessage() {\n\t}\n\n}\n\nexport default UI\n","/** @module dom-lookup Utils module for looking up elements on the default UI */\n\nimport { waitForElement } from \"../../dom/async-events.js\"\n\n/**\n * Finds the scrollable messages container inside the conversation panel.\n * Instagram removed role=\"grid\" — we now locate the container via aria-label\n * and walk into its scrollable child.\n *\n * @param {Window} window\n * @returns {HTMLDivElement|null}\n */\nexport function findMessagesWrapper(window) {\n\tconst conversation = window.document.querySelector(\"[aria-label^='Conversation']\")\n\tif (!conversation) {\n\t\treturn null\n\t}\n\tconst scrollable = findScrollableChild(conversation, window)\n\tif (!scrollable) {\n\t\treturn null\n\t}\n\treturn scrollable\n}\n\n/**\n * Recursively finds the first scrollable descendant of a given element.\n *\n * @param {Element} parent\n * @param {Window} window\n * @returns {HTMLDivElement|null}\n */\nfunction findScrollableChild(parent, window) {\n\tfor (const child of parent.children) {\n\t\tconst style = window.getComputedStyle(child)\n\t\tif (\n\t\t\t(style.overflowY === \"auto\" || style.overflowY === \"scroll\") &&\n\t\t\tchild.scrollHeight > child.clientHeight\n\t\t) {\n\t\t\treturn child\n\t\t}\n\t\tconst found = findScrollableChild(child, window)\n\t\tif (found) {\n\t\t\treturn found\n\t\t}\n\t}\n\treturn null\n}\n\n/**\n * Returns the inner container that holds individual message row divs.\n * Traverses wrapper layers to find the div with the most children (the message list).\n *\n * @param {Element} scrollable\n * @returns {HTMLDivElement}\n */\nexport function getMessagesInnerContainer(scrollable) {\n\t// Instagram wraps messages in several nested divs.\n\t// Strategy: find the deepest descendant (within 3 levels) that has the most children,\n\t// since the actual messages container has many direct children (one per message row).\n\tlet best = scrollable\n\tlet bestCount = scrollable.children.length\n\n\tfunction search(el, depth) {\n\t\tif (depth > 3) return\n\t\tfor (const child of el.children) {\n\t\t\tif (child.children.length > bestCount) {\n\t\t\t\tbest = child\n\t\t\t\tbestCount = child.children.length\n\t\t\t}\n\t\t\tsearch(child, depth + 1)\n\t\t}\n\t}\n\n\tsearch(scrollable, 0)\n\treturn best\n}\n\n/**\n * Determines whether a message element was sent by the current user.\n * Instagram aligns sent messages to the right using flexbox (justify-content: flex-end).\n *\n * @param {Element} element\n * @param {Window} window\n * @returns {boolean}\n */\nexport function isSentByCurrentUser(element, window) {\n\t// BFS through all descendants up to depth 8.\n\t// Instagram places justify-content: flex-end on a nested div (depth ~5)\n\t// that may be on any child branch, not just the first-child path.\n\tconst queue = [{ el: element, depth: 0 }]\n\twhile (queue.length > 0) {\n\t\tconst { el, depth } = queue.shift()\n\t\tconst s = window.getComputedStyle(el)\n\t\tif (s.justifyContent === \"flex-end\") {\n\t\t\treturn true\n\t\t}\n\t\tif (depth < 8) {\n\t\t\tfor (const child of el.children) {\n\t\t\t\tqueue.push({ el: child, depth: depth + 1 })\n\t\t\t}\n\t\t}\n\t}\n\treturn false\n}\n\n/**\n * Gets the first visible message sent by the current user that hasn't been processed yet.\n *\n * @param {Element} root - The scrollable messages wrapper\n * @param {AbortController} abortController\n * @param {Window} window\n * @returns {Element|undefined}\n */\nexport function getFirstVisibleMessage(root, abortController, window) {\n\tconst innerContainer = getMessagesInnerContainer(root)\n\tif (!innerContainer) {\n\t\tconsole.debug(\"getFirstVisibleMessage: no inner container found\")\n\t\treturn\n\t}\n\n\tconst elements = [...innerContainer.children]\n\t\t.filter(d => {\n\t\t\tif (d.hasAttribute(\"data-idmu-ignore\")) return false\n\t\t\tif (d.hasAttribute(\"data-idmu-unsent\")) return false\n\t\t\t// Must contain message content indicators\n\t\t\tconst hasMessageContent = d.querySelector(\"[role=none]\") || d.querySelector(\"[role=presentation]\")\n\t\t\tif (!hasMessageContent) return false\n\t\t\treturn isSentByCurrentUser(d, window)\n\t\t})\n\n\telements.reverse()\n\tif(elements.length >= 1) {\n\t\tconsole.debug(\"getFirstVisibleMessage\", elements.length, \"candidate elements\")\n\t} else {\n\t\tconsole.error(\"getFirstVisibleMessage could not find any elements. If there actually are messages on the page that means the query selector might be out of date.\")\n\t}\n\n\tfor (const element of elements) {\n\t\tif (abortController.signal.aborted) {\n\t\t\tconsole.debug(\"abortController interupted the message filtering process: stopping...\")\n\t\t\tbreak\n\t\t}\n\t\tconst visibilityCheck = element.checkVisibility({\n\t\t\tvisibilityProperty: true,\n\t\t\tcontentVisibilityAuto: true,\n\t\t\topacityProperty: true,\n\t\t})\n\t\tif (visibilityCheck === false) {\n\t\t\tconsole.debug(\"visibilityCheck\", visibilityCheck)\n\t\t\tcontinue\n\t\t}\n\t\tconst rect = element.getBoundingClientRect()\n\t\t// Check if element is at least partially in viewport.\n\t\t// For tall elements (images, long text), rect.y can be negative\n\t\t// while the element is still visible. Use bottom edge instead.\n\t\tif (rect.y + rect.height < 50 || rect.height === 0) {\n\t\t\tconsole.debug(\"isInView failed\", rect.y, rect.height)\n\t\t\tcontinue\n\t\t}\n\t\telement.setAttribute(\"data-idmu-ignore\", \"\")\n\t\tconsole.debug(\"Message in view, testing workflow...\", element)\n\t\treturn element\n\t}\n}\n\n/**\n * Scrolls to top to trigger loading of older messages.\n * Handles both normal and column-reverse layouts.\n *\n * In column-reverse (Instagram's current layout):\n *   scrollTop=0 is the BOTTOM (newest messages)\n *   scrollTop=-(scrollHeight-clientHeight) is the TOP (oldest messages)\n *\n * @param {Element} root\n * @param {AbortController} abortController\n * @returns {Promise<boolean>}\n */\nexport async function loadMoreMessages(root, abortController) {\n\tconsole.debug(\"loadMoreMessages looking for loader... \")\n\tconst scrollAbortController = new AbortController()\n\tlet findLoaderTimeout\n\tlet resolveTimeout\n\tconst abortHandler = () => {\n\t\tscrollAbortController.abort()\n\t\tclearTimeout(findLoaderTimeout)\n\t\tif (resolveTimeout) {\n\t\t\tresolveTimeout()\n\t\t}\n\t}\n\tabortController.signal.addEventListener(\"abort\", abortHandler)\n\n\t// Detect column-reverse layout\n\tconst style = root.ownerDocument.defaultView.getComputedStyle(root)\n\tconst isReversed = style.flexDirection === \"column-reverse\"\n\t// In column-reverse, \"scroll to top\" means most negative scrollTop\n\tconst scrollToTopValue = isReversed\n\t\t? -(root.scrollHeight - root.clientHeight)\n\t\t: 0\n\t// In column-reverse, \"at top\" means scrollTop is at or near minimum\n\tconst isAtTop = () => isReversed\n\t\t? root.scrollTop <= scrollToTopValue + 5\n\t\t: root.scrollTop === 0\n\n\tconst beforeScroll = root.scrollTop\n\tconst beforeHeight = root.scrollHeight\n\troot.scrollTop = scrollToTopValue\n\n\t// Helper: find a visible loader within the scrollable root's viewport\n\tconst findVisibleLoader = () => {\n\t\tconst bars = root.querySelectorAll(\"[role=progressbar]\")\n\t\tfor (const bar of bars) {\n\t\t\tconst rect = bar.getBoundingClientRect()\n\t\t\tconst rootRect = root.getBoundingClientRect()\n\t\t\t// Must be within root's horizontal+vertical bounds and have dimensions\n\t\t\tif (rect.height > 0 && rect.y >= rootRect.y - 100 && rect.y <= rootRect.y + rootRect.height + 100) {\n\t\t\t\treturn bar\n\t\t\t}\n\t\t}\n\t\treturn null\n\t}\n\n\t// Short chat: everything fits in viewport, nothing to load\n\tconst noScrollNeeded = isReversed\n\t\t? beforeScroll === 0 && root.scrollHeight <= root.clientHeight + 50\n\t\t: beforeScroll === 0 && root.scrollHeight <= root.clientHeight + 50\n\tif (noScrollNeeded) {\n\t\tconsole.debug(\"loadMoreMessages: chat fits in viewport, marking as done\")\n\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\treturn true\n\t}\n\n\t// Already at top after scrolling: wait briefly for new content, then check\n\tif (isAtTop()) {\n\t\t// Give Instagram a moment to start loading older messages\n\t\tawait new Promise(resolve => setTimeout(resolve, 500))\n\n\t\t// Check if a visible loader appeared\n\t\tconst loader = findVisibleLoader()\n\t\tif (loader) {\n\t\t\tconsole.debug(\"loadMoreMessages: Found visible loader after scroll; waiting for removal (max 5s)\")\n\t\t\tawait Promise.race([\n\t\t\t\twaitForElement(root, () => findVisibleLoader() === null, abortController),\n\t\t\t\tnew Promise(resolve => setTimeout(resolve, 5000))\n\t\t\t])\n\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t\tconst grew = root.scrollHeight > beforeHeight\n\t\t\tconsole.debug(`loadMoreMessages: loader phase done, content ${grew ? \"grew\" : \"did not grow\"}`)\n\t\t\treturn !grew\n\t\t}\n\n\t\t// No loader appeared — check if scrollHeight grew (new content loaded without spinner)\n\t\tconst grew = root.scrollHeight > beforeHeight\n\t\tif (!grew) {\n\t\t\tconsole.debug(\"loadMoreMessages: at top, no loader, no new content — reached last page\")\n\t\t\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\t\t\treturn true\n\t\t}\n\t}\n\n\t// Fallback: wait for progressbar to appear (with shorter timeout)\n\tlet loadingElement\n\ttry {\n\t\tloadingElement = await Promise.race([\n\t\t\twaitForElement(root, () => {\n\t\t\t\tif (findVisibleLoader() === null) {\n\t\t\t\t\troot.scrollTop = scrollToTopValue\n\t\t\t\t}\n\t\t\t\treturn findVisibleLoader()\n\t\t\t}, scrollAbortController),\n\t\t\tnew Promise(resolve => {\n\t\t\t\tresolveTimeout = resolve\n\t\t\t\tfindLoaderTimeout = setTimeout(() => {\n\t\t\t\t\tresolve()\n\t\t\t\t}, 3000)\n\t\t\t})\n\t\t])\n\t} catch (ex) {\n\t\tconsole.error(ex)\n\t}\n\tscrollAbortController.abort()\n\tabortController.signal.removeEventListener(\"abort\", abortHandler)\n\tclearTimeout(findLoaderTimeout)\n\tif (loadingElement && loadingElement !== true) {\n\t\tconsole.debug(\"loadMoreMessages: Found loader; Stand-by until it is removed (max 5s)\")\n\t\tawait Promise.race([\n\t\t\twaitForElement(root, () => findVisibleLoader() === null, abortController),\n\t\t\tnew Promise(resolve => setTimeout(resolve, 5000))\n\t\t])\n\t}\n\tconst atTop = isAtTop()\n\tconsole.debug(`loadMoreMessages: scrollTop is ${root.scrollTop} — ${atTop ? \"reached last page\" : \"not last page\"}`)\n\treturn atTop\n}\n\n","/** @module ui-messages-wrapper UI element representing the messages wrapper */\n\nimport { loadMoreMessages } from \"./dom-lookup.js\"\nimport UIComponent from \"../ui-component.js\"\n\nclass UIMessagesWrapper extends UIComponent {\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise}\n\t */\n\tfetchAndRenderThreadNextMessagePage(abortController) {\n\t\treturn loadMoreMessages(this.root, abortController)\n\t}\n\n}\n\nexport default UIMessagesWrapper\n","/** @module default-ui Default UI / English UI */\n\nimport UI from \"../ui.js\"\nimport { findMessagesWrapper, getFirstVisibleMessage } from \"./dom-lookup.js\"\nimport UIPIMessage from \"../../uipi/uipi-message.js\"\nimport UIMessage from \"./ui-message.js\"\nimport UIMessagesWrapper from \"./ui-messages-wrapper.js\"\n\nclass DefaultUI extends UI {\n\n\tconstructor(root, identifier = {}) {\n\t\tsuper(root, identifier)\n\t\tthis.lastScrollTop = null\n\t}\n\n\t/**\n\t * @param {Window} window\n\t * @returns {DefaultUI}\n\t */\n\tstatic create(window) {\n\t\tconsole.debug(\"UI create: Looking for messagesWrapperElement\")\n\t\tconst messagesWrapperElement = findMessagesWrapper(window)\n\t\tif (messagesWrapperElement !== null) {\n\t\t\tconsole.debug(\"Found messagesWrapperElement\", messagesWrapperElement)\n\t\t\tconst uiMessagesWrapper = new UIMessagesWrapper(messagesWrapperElement)\n\t\t\treturn new DefaultUI(window, { uiMessagesWrapper })\n\t\t} else {\n\t\t\tthrow new Error(\"Unable to find messagesWrapperElement. The query selector might be out of date.\")\n\t\t}\n\t}\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise}\n\t */\n\tasync fetchAndRenderThreadNextMessagePage(abortController) {\n\t\tconsole.debug(\"UI fetchAndRenderThreadNextMessagePage\")\n\t\treturn await this.identifier.uiMessagesWrapper.fetchAndRenderThreadNextMessagePage(abortController)\n\t}\n\n\t/**\n\t * Scroll until a (visible) message is found and return it.\n\t *\n\t * Instagram uses flex-direction: column-reverse on the messages container.\n\t * This means scrollTop=0 is the BOTTOM (newest messages) and scrolling to\n\t * older messages requires NEGATIVE scrollTop values.\n\t * In normal (non-reversed) layouts, scrollTop=0 is the top and the max is positive.\n\t *\n\t * This method detects the layout direction and scrolls accordingly.\n\t *\n\t * @param {AbortController} abortController\n\t * @returns {Promise<UIPIMessage|false>}\n\t */\n\tasync getNextUIPIMessage(abortController) {\n\t\tconsole.debug(\"UI getNextUIPIMessage\", this.lastScrollTop)\n\t\tconst uiMessagesWrapperRoot = this.identifier.uiMessagesWrapper.root\n\n\t\t// Detect column-reverse: scrollTop can go negative\n\t\tconst style = this.root.getComputedStyle\n\t\t\t? this.root.getComputedStyle(uiMessagesWrapperRoot)\n\t\t\t: uiMessagesWrapperRoot.ownerDocument.defaultView.getComputedStyle(uiMessagesWrapperRoot)\n\t\tconst isReversed = style.flexDirection === \"column-reverse\"\n\n\t\t// Allow up to 3 full passes; covers cases where DOM shrinks after unsends\n\t\tfor (let pass = 0; pass < 3; pass++) {\n\t\t\tif (isReversed) {\n\t\t\t\t// column-reverse: scrollTop ranges from 0 (bottom/newest) to negative (top/oldest)\n\t\t\t\t// minScroll is the most negative value (furthest back in history)\n\t\t\t\tconst minScroll = -(uiMessagesWrapperRoot.scrollHeight - uiMessagesWrapperRoot.clientHeight)\n\t\t\t\tconst startPos = (pass === 0 && this.lastScrollTop !== null)\n\t\t\t\t\t? Math.max(this.lastScrollTop, minScroll)\n\t\t\t\t\t: 0 // Start from bottom (newest)\n\t\t\t\tconsole.debug(`getNextUIPIMessage [reversed] pass=${pass}, startPos=${startPos}, minScroll=${minScroll}`)\n\n\t\t\t\t// Scroll from startPos toward minScroll (more negative = older messages)\n\t\t\t\tfor (let i = startPos; i >= minScroll; i = i - 150) {\n\t\t\t\t\tif (abortController.signal.aborted) {\n\t\t\t\t\t\tconsole.debug(\"abortController interupted the scrolling: stopping...\")\n\t\t\t\t\t\treturn false\n\t\t\t\t\t}\n\t\t\t\t\tthis.lastScrollTop = i\n\t\t\t\t\tuiMessagesWrapperRoot.scrollTop = i\n\t\t\t\t\tuiMessagesWrapperRoot.dispatchEvent(new this.root.Event(\"scroll\"))\n\t\t\t\t\tawait new Promise(resolve => setTimeout(resolve, 5))\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst messageElement = getFirstVisibleMessage(uiMessagesWrapperRoot, abortController, this.root)\n\t\t\t\t\t\tif (messageElement) {\n\t\t\t\t\t\t\tconst uiMessage = new UIMessage(messageElement)\n\t\t\t\t\t\t\treturn new UIPIMessage(uiMessage)\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch (ex) {\n\t\t\t\t\t\tconsole.error(ex)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Normal layout: scrollTop ranges from 0 (top) to positive max (bottom)\n\t\t\t\tconst maxScroll = uiMessagesWrapperRoot.scrollHeight - uiMessagesWrapperRoot.clientHeight\n\t\t\t\tconst startScrollTop = (pass === 0 && this.lastScrollTop !== null)\n\t\t\t\t\t? Math.min(this.lastScrollTop, maxScroll)\n\t\t\t\t\t: maxScroll\n\t\t\t\tconsole.debug(`getNextUIPIMessage pass=${pass}, startScrollTop=${startScrollTop}, maxScroll=${maxScroll}`)\n\n\t\t\t\tfor (let i = Math.max(1, startScrollTop); i > 0; i = i - 150) {\n\t\t\t\t\tif (abortController.signal.aborted) {\n\t\t\t\t\t\tconsole.debug(\"abortController interupted the scrolling: stopping...\")\n\t\t\t\t\t\treturn false\n\t\t\t\t\t}\n\t\t\t\t\tthis.lastScrollTop = i\n\t\t\t\t\tuiMessagesWrapperRoot.scrollTop = i\n\t\t\t\t\tuiMessagesWrapperRoot.dispatchEvent(new this.root.Event(\"scroll\"))\n\t\t\t\t\tawait new Promise(resolve => setTimeout(resolve, 5))\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst messageElement = getFirstVisibleMessage(uiMessagesWrapperRoot, abortController, this.root)\n\t\t\t\t\t\tif (messageElement) {\n\t\t\t\t\t\t\tconst uiMessage = new UIMessage(messageElement)\n\t\t\t\t\t\t\treturn new UIPIMessage(uiMessage)\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch (ex) {\n\t\t\t\t\t\tconsole.error(ex)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Reached the end without finding a message.\n\t\t\t// Reset for a fresh pass (DOM may have shrunk after unsends).\n\t\t\tthis.lastScrollTop = null\n\t\t\tconsole.debug(`getNextUIPIMessage: pass ${pass} found nothing, retrying`)\n\t\t}\n\n\t\tconsole.debug(\"getNextUIPIMessage: exhausted all passes, no messages left\")\n\t\treturn false\n\t}\n\n}\n\nexport default DefaultUI\n","/** @module get-ui UI loader module. Allow loading of a certain UI based on a given strategy (locale etc..)\n * There might be need for multiple UI as Instagram might serve different apps based on location for example.\n * There is also a need to internationalize each ui so that it doesn't fail if we change the language.\n */\n\nimport DefaultUI from \"./default/default-ui.js\"\n/* eslint-disable-next-line no-unused-vars */\nimport UI from \"./ui.js\"\n\n/**\n *\n * @returns {UI}\n */\nexport default function getUI() {\n\treturn DefaultUI\n}\n","/** @module uipi API for UI */\n\nimport getUI from \"../ui/get-ui.js\"\n\n/* eslint-disable-next-line no-unused-vars */\nimport UI from \"../ui/ui.js\"\n/* eslint-disable-next-line no-unused-vars */\nimport UIPIMessage from \"./uipi-message.js\"\n\n/**\n * UI Interface API\n */\nclass UIPI {\n\n\t/**\n\t *\n\t * @param {UI} ui\n\t */\n\tconstructor(ui) {\n\t\tthis._ui = ui\n\t}\n\n\t/**\n\t *\n\t * @param {Window} window\n\t * @returns {UIPI}\n\t */\n\tstatic create(window) {\n\t\tconsole.debug(\"UIPI.create\")\n\t\tconst ui = getUI().create(window)\n\t\treturn new UIPI(ui)\n\t}\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise}\n\t */\n\tfetchAndRenderThreadNextMessagePage(abortController) {\n\t\tconsole.debug(\"UIPI fetchAndRenderThreadNextMessagePage\")\n\t\treturn this.ui.fetchAndRenderThreadNextMessagePage(abortController)\n\t}\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise<UIPIMessage>}\n\t */\n\tgetNextUIPIMessage(abortController) {\n\t\tconsole.debug(\"UIPI getNextUIPIMessage\")\n\t\treturn this.ui.getNextUIPIMessage(abortController)\n\t}\n\n\t/**\n\t *\n\t * @type {UI}\n\t */\n\tget ui() {\n\t\treturn this._ui\n\t}\n\n}\n\nexport default UIPI\n","/** @module idmu Global/Main API for interacting with the UI */\n\nimport UIPI from \"../uipi/uipi.js\"\n/* eslint-disable-next-line no-unused-vars */\nimport UIPIMessage from \"../uipi/uipi-message.js\"\n\nclass IDMU {\n\n\t/**\n\t *\n\t * @param {Window} window\n\t * @param {callback} onStatusText\n\t */\n\tconstructor(window, onStatusText) {\n\t\tthis.window = window\n\t\tthis.uipi = null\n\t\tthis.onStatusText = onStatusText\n\t}\n\n\t/**\n\t * @param {AbortController} abortController\n\t * @returns {Promise<UIPIMessage>}\n\t */\n\tgetNextUIPIMessage(abortController) {\n\t\treturn this.uipi.getNextUIPIMessage(abortController)\n\t}\n\n\t/**\n\t *\n\t * @param {string} text\n\t */\n\tsetStatusText(text) {\n\t\tthis.onStatusText(text)\n\t}\n\n\n\t/**\n\t *\n\t * @param {AbortController} abortController\n\t * @returns {Promise}\n\t */\n\tfetchAndRenderThreadNextMessagePage(abortController) {\n\t\treturn this.uipi.fetchAndRenderThreadNextMessagePage(abortController)\n\t}\n\n\t/**\n\t * Map Instagram UI\n\t */\n\tloadUIPI() {\n\t\tconsole.debug(\"loadUIPI\")\n\t\tthis.uipi = UIPI.create(this.window)\n\t}\n\n\n}\nexport default IDMU\n","/** @module unsend-strategy Various strategies for unsending messages */\n\n/* eslint-disable-next-line no-unused-vars */\nimport IDMU from \"../idmu/idmu.js\"\n\n/**\n *\n * @abstract\n */\nclass UnsendStrategy {\n\n\t/**\n\t *\n\t * @param {IDMU} idmu\n\t */\n\tconstructor(idmu) {\n\t\tthis._idmu = idmu\n\t}\n\n\t/**\n\t *\n\t * @abstract\n\t * @returns {boolean}\n\t */\n\tisRunning() {\n\t}\n\n\t/**\n\t *\n\t * @abstract\n\t */\n\tstop() {\n\t}\n\n\t/**\n\t *\n\t * @abstract\n\t */\n\treset() {\n\t}\n\n\t/**\n\t *\n\t * @abstract\n\t */\n\tasync run() {\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {IDMU}\n\t */\n\tget idmu() {\n\t\treturn this._idmu\n\t}\n\n}\n\nexport { UnsendStrategy }\n","/** @module unsend-strategy Various strategies for unsending messages */\n\n/* eslint-disable-next-line no-unused-vars */\nimport IDMU from \"../../idmu/idmu.js\"\nimport { UnsendStrategy } from \"../unsend-strategy.js\"\n\n/**\n * Loads all pages first, then unsends messages from bottom to top.\n * For short conversations (all messages fit in viewport), skips page loading entirely.\n */\nclass DefaultStrategy extends UnsendStrategy {\n\n\t/**\n\t * @param {IDMU} idmu\n\t */\n\tconstructor(idmu) {\n\t\tsuper(idmu)\n\t\tthis._allPagesLoaded = false\n\t\tthis._unsentCount = 0\n\t\tthis._pagesLoadedCount = 0\n\t\tthis._running = false\n\t\tthis._abortController = null\n\t\tthis._lastUnsendDate = null\n\t\tthis._consecutiveFailures = 0\n\t}\n\n\t/**\n\t * @returns {boolean}\n\t */\n\tisRunning() {\n\t\treturn this._running && this._abortController && this._abortController.signal.aborted === false\n\t}\n\n\tstop() {\n\t\tconsole.debug(\"DefaultStrategy stop\")\n\t\tthis.idmu.setStatusText(\"Stopping...\")\n\t\tthis._abortController.abort()\n\t}\n\n\treset() {\n\t\tthis._allPagesLoaded = false\n\t\tthis._unsentCount = 0\n\t\tthis._lastUnsendDate = null\n\t\tthis._pagesLoadedCount = 0\n\t\tthis._consecutiveFailures = 0\n\t\tthis.idmu.setStatusText(\"Ready\")\n\t}\n\n\t/**\n\t * @returns {Promise}\n\t */\n\tasync run() {\n\t\tconsole.debug(\"DefaultStrategy.run()\")\n\t\tthis._unsentCount = 0\n\t\tthis._pagesLoadedCount = 0\n\t\tthis._consecutiveFailures = 0\n\t\tthis._running = true\n\t\tthis._abortController = new AbortController()\n\t\t// Clear stale ignore markers from previous runs so messages can be retried\n\t\tthis.idmu.window.document.querySelectorAll(\"[data-idmu-ignore]\").forEach(el => {\n\t\t\tel.removeAttribute(\"data-idmu-ignore\")\n\t\t})\n\t\tthis.idmu.loadUIPI()\n\t\ttry {\n\t\t\tif (this._allPagesLoaded) {\n\t\t\t\tawait this.#unsendNextMessage()\n\t\t\t} else {\n\t\t\t\tawait this.#loadNextPage()\n\t\t\t}\n\n\t\t\t// Race condition: on first page load, Instagram's React may not have\n\t\t\t// finished hydrating message components (role attributes missing).\n\t\t\t// If we found nothing, wait and re-scan up to 3 times.\n\t\t\tif (this._unsentCount === 0 && !this._abortController.signal.aborted) {\n\t\t\t\tfor (let retry = 1; retry <= 3; retry++) {\n\t\t\t\t\tthis.idmu.setStatusText(`No messages detected, retrying (${retry}/3)...`)\n\t\t\t\t\tconsole.debug(`DefaultStrategy: 0 messages found, retry ${retry}/3`)\n\t\t\t\t\tawait new Promise(resolve => setTimeout(resolve, 2000))\n\t\t\t\t\tif (this._abortController.signal.aborted) break\n\t\t\t\t\t// Reset for fresh scan\n\t\t\t\t\tthis._allPagesLoaded = false\n\t\t\t\t\tthis._consecutiveFailures = 0\n\t\t\t\t\tthis.idmu.window.document.querySelectorAll(\"[data-idmu-ignore]\").forEach(el => {\n\t\t\t\t\t\tel.removeAttribute(\"data-idmu-ignore\")\n\t\t\t\t\t})\n\t\t\t\t\tthis.idmu.loadUIPI()\n\t\t\t\t\tawait this.#loadNextPage()\n\t\t\t\t\tif (this._unsentCount > 0 || this._abortController.signal.aborted) break\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (this._abortController.signal.aborted) {\n\t\t\t\tthis.idmu.setStatusText(`Aborted. ${this._unsentCount} message(s) unsent.`)\n\t\t\t\tconsole.debug(\"DefaultStrategy aborted\")\n\t\t\t} else {\n\t\t\t\tthis.idmu.setStatusText(`Done. ${this._unsentCount} message(s) unsent.`)\n\t\t\t\tconsole.debug(\"DefaultStrategy done\")\n\t\t\t}\n\t\t} catch (ex) {\n\t\t\tconsole.error(ex)\n\t\t\tthis.idmu.setStatusText(`Errored. ${this._unsentCount} message(s) unsent.`)\n\t\t\tconsole.debug(\"DefaultStrategy errored\")\n\t\t}\n\t\tthis._running = false\n\t}\n\n\t/**\n\t * Tries to load the thread next page.\n\t * If loadMoreMessages returns true (no more pages), moves to unsending.\n\t */\n\tasync #loadNextPage() {\n\t\tif (this._abortController.signal.aborted) {\n\t\t\tconsole.debug(\"abortController interupted the loading of next page: stopping...\")\n\t\t\treturn\n\t\t}\n\t\tthis.idmu.setStatusText(\"Loading next page...\")\n\t\ttry {\n\t\t\tconst done = await this.idmu.fetchAndRenderThreadNextMessagePage(this._abortController)\n\t\t\tif (this._abortController.signal.aborted === false) {\n\t\t\t\tif (done) {\n\t\t\t\t\tthis.idmu.setStatusText(`All pages loaded (${this._pagesLoadedCount} in total). Unsending...`)\n\t\t\t\t\tthis._allPagesLoaded = true\n\t\t\t\t\tawait this.#unsendNextMessage()\n\t\t\t\t} else {\n\t\t\t\t\tthis._pagesLoadedCount++\n\t\t\t\t\tawait this.#loadNextPage()\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconsole.debug(\"abortController interupted the loading of next page: stopping...\")\n\t\t\t}\n\t\t} catch (ex) {\n\t\t\tconsole.error(ex)\n\t\t}\n\t}\n\n\t/**\n\t * Unsend first message in viewport.\n\t * Uses human-like randomized delays and exponential backoff to avoid Instagram rate limits.\n\t */\n\tasync #unsendNextMessage() {\n\t\tif (this._abortController.signal.aborted) {\n\t\t\tconsole.debug(\"abortController interupted the unsending of next message: stopping...\")\n\t\t\treturn\n\t\t}\n\t\tif (this._consecutiveFailures >= 5) {\n\t\t\tthis.idmu.setStatusText(`Stopped: ${this._consecutiveFailures} consecutive failures. ${this._unsentCount} message(s) unsent.`)\n\t\t\tconsole.debug(\"DefaultStrategy stopping due to consecutive failures\")\n\t\t\treturn\n\t\t}\n\t\tlet canScroll = true\n\t\tlet msgElement = null\n\t\ttry {\n\t\t\tthis.idmu.setStatusText(`Retrieving next message... (${this._unsentCount} unsent so far)`)\n\t\t\tconst uipiMessage = await this.idmu.getNextUIPIMessage(this._abortController)\n\t\t\tcanScroll = uipiMessage !== false\n\t\t\tif (uipiMessage) {\n\t\t\t\tthis.idmu.setStatusText(`Unsending message... (${this._unsentCount + 1})`)\n\n\t\t\t\t// Human-like delay between unsends: 3-6s randomized\n\t\t\t\tif (this._lastUnsendDate !== null) {\n\t\t\t\t\tconst elapsed = Date.now() - this._lastUnsendDate.getTime()\n\t\t\t\t\tconst minDelay = 4000 + Math.floor(Math.random() * 2000) // 4-6s (~5s avg)\n\t\t\t\t\tif (elapsed < minDelay) {\n\t\t\t\t\t\tconst waitMs = minDelay - elapsed\n\t\t\t\t\t\tthis.idmu.setStatusText(`Waiting ${(waitMs / 1000).toFixed(1)}s... (${this._unsentCount} unsent so far)`)\n\t\t\t\t\t\tawait new Promise(resolve => setTimeout(resolve, waitMs))\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (this._abortController.signal.aborted) return\n\n\t\t\t\tmsgElement = uipiMessage.uiMessage.root\n\t\t\t\tconst unsent = await uipiMessage.unsend(this._abortController)\n\n\t\t\t\tif (unsent) {\n\t\t\t\t\t// Verify the message actually disappeared from DOM (server accepted the mutation)\n\t\t\t\t\tawait new Promise(resolve => setTimeout(resolve, 800))\n\t\t\t\t\tconst stillInDOM = msgElement.isConnected && !msgElement.hasAttribute(\"data-idmu-unsent\")\n\t\t\t\t\tif (stillInDOM) {\n\t\t\t\t\t\t// Server likely rejected — the message reappeared after optimistic removal\n\t\t\t\t\t\tconsole.debug(\"DefaultStrategy: message still in DOM after unsend, possible rate limit\")\n\t\t\t\t\t\tmsgElement.removeAttribute(\"data-idmu-ignore\")\n\t\t\t\t\t\tthis._consecutiveFailures++\n\t\t\t\t\t\tconst backoffMs = Math.min(60000, 5000 * Math.pow(2, this._consecutiveFailures - 1))\n\t\t\t\t\t\tthis.idmu.setStatusText(`Server may have rejected unsend. Backing off ${(backoffMs / 1000).toFixed(0)}s... (${this._unsentCount} unsent)`)\n\t\t\t\t\t\tawait new Promise(resolve => setTimeout(resolve, backoffMs))\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis._lastUnsendDate = new Date()\n\t\t\t\t\t\tthis._unsentCount++\n\t\t\t\t\t\tthis._consecutiveFailures = 0\n\t\t\t\t\t\t// DOM shrunk after removal; reset scroll for fresh scan\n\t\t\t\t\t\tif (this.idmu.uipi && this.idmu.uipi.ui) {\n\t\t\t\t\t\t\tthis.idmu.uipi.ui.lastScrollTop = null\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// Unsend workflow returned false — allow retry on next pass\n\t\t\t\t\tconsole.debug(\"DefaultStrategy: unsend returned false, removing ignore marker for retry\")\n\t\t\t\t\tmsgElement.removeAttribute(\"data-idmu-ignore\")\n\t\t\t\t\tthis._consecutiveFailures++\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (ex) {\n\t\t\tconsole.error(ex)\n\t\t\t// Remove ignore marker so this message can be retried\n\t\t\tif (msgElement) {\n\t\t\t\tmsgElement.removeAttribute(\"data-idmu-ignore\")\n\t\t\t}\n\t\t\tthis._consecutiveFailures++\n\t\t\tconst backoffMs = Math.min(60000, 3000 * Math.pow(2, this._consecutiveFailures - 1))\n\t\t\tthis.idmu.setStatusText(`Workflow failed (${this._consecutiveFailures}/5), retrying in ${(backoffMs / 1000).toFixed(0)}s... (${this._unsentCount} unsent)`)\n\t\t\tawait new Promise(resolve => setTimeout(resolve, backoffMs))\n\t\t} finally {\n\t\t\tif (canScroll && this._abortController && !this._abortController.signal.aborted) {\n\t\t\t\tawait this.#unsendNextMessage()\n\t\t\t}\n\t\t}\n\t}\n\n}\n\nexport { DefaultStrategy }\n","/** @module alert Alert UI */\n\n/**\n *\n * @param {Document} document\n * @returns {HTMLButtonElement}\n */\nexport function createAlertsWrapperElement(document) {\n\tconst alertsWrapperElement = document.createElement(\"div\")\n\talertsWrapperElement.id = \"idmu-alerts\"\n\talertsWrapperElement.style.position = \"fixed\"\n\talertsWrapperElement.style.top = \"20px\"\n\talertsWrapperElement.style.right = \"20px\"\n\talertsWrapperElement.style.display = \"grid\"\n\treturn alertsWrapperElement\n}\n\n/**\n *\n * @param {Document} document\n * @param {string}   text\n * @returns {HTMLButtonElement}\n */\nexport function createAlertElement(document, text) {\n\tconst alertElement = document.createElement(\"div\")\n\talertElement.textContent = text\n\treturn alertElement\n}\n","/** @module overlay IDMU's overlay */\n\n/**\n * @param {Document} document\n * @returns {HTMLDivElement}\n */\nexport function createOverlayElement(document) {\n\tconst overlayElement = document.createElement(\"div\")\n\toverlayElement.id = \"idmu-overlay\"\n\toverlayElement.tabIndex = 0\n\toverlayElement.style.top = \"0\"\n\toverlayElement.style.right = \"0\"\n\toverlayElement.style.position = \"fixed\"\n\toverlayElement.style.width = \"100vw\"\n\toverlayElement.style.height = \"100vh\"\n\toverlayElement.style.zIndex = \"998\"\n\toverlayElement.style.backgroundColor = \"#000000d6\"\n\toverlayElement.style.display = \"none\"\n\treturn overlayElement\n}\n","/** @module ui IDMU's own ui/overlay\n * Provide a button to unsend messages\n */\n\nimport { createMenuButtonElement } from \"./menu-button.js\"\nimport { createMenuElement } from \"./menu.js\"\nimport IDMU from \"../../../idmu/idmu.js\"\nimport { DefaultStrategy } from \"../../../ui/default/unsend-strategy.js\"\nimport { createAlertsWrapperElement } from \"./alert.js\"\nimport { createOverlayElement } from \"./overlay.js\"\nimport { BUTTON_STYLE } from \"./style/instagram.js\"\n/* eslint-disable-next-line no-unused-vars */\nimport { UnsendStrategy } from \"../../../ui/unsend-strategy.js\"\n\nclass OSD {\n\t/**\n\t *\n\t * @param {Document} document\n\t * @param {HTMLDivElement} root\n\t * @param {HTMLDivElement} overlayElement\n\t * @param {HTMLDivElement} menuElement\n\t * @param {HTMLButtonElement} unsendThreadMessagesButton\n\t * @param {HTMLDivElement} statusElement\n\t */\n\tconstructor(document, root, overlayElement, menuElement, unsendThreadMessagesButton, statusElement) {\n\t\tthis._document = document\n\t\tthis._root = root\n\t\tthis._overlayElement = overlayElement\n\t\tthis._menuElement = menuElement\n\t\tthis._statusElement = statusElement\n\t\tthis._unsendThreadMessagesButton = unsendThreadMessagesButton\n\t\tthis._idmu = new IDMU(this.window, this.onStatusText.bind(this))\n\t\tthis._strategy = new DefaultStrategy(this._idmu) // TODO move out\n\t}\n\n\t/**\n\t *\n\t * @param {window} window\n\t * @returns {OSD}\n\t */\n\tstatic render(window) {\n\t\tconsole.debug(\"render\")\n\t\tconst ui = OSD.create(window.document)\n\t\twindow.document.body.appendChild(ui.root)\n\t\treturn ui\n\t}\n\n\t/**\n\t *\n\t * @param   {Document} document\n\t * @returns {OSD}\n\t */\n\tstatic create(document) {\n\t\tconst root = document.createElement(\"div\")\n\t\troot.id = \"idmu-root\"\n\t\tconst menuElement = createMenuElement(document)\n\t\tconst overlayElement = createOverlayElement(document)\n\t\tconst alertsWrapperElement = createAlertsWrapperElement(document)\n\t\tconst unsendThreadMessagesButton = createMenuButtonElement(document, \"Unsend all DMs\", BUTTON_STYLE.PRIMARY)\n\t\tconst statusElement = document.createElement(\"div\")\n\t\tstatusElement.textContent = \"Ready\"\n\t\tstatusElement.id = \"idmu-status\"\n\t\tstatusElement.style = \"width: 200px\"\n\t\tdocument.body.appendChild(overlayElement)\n\t\tdocument.body.appendChild(alertsWrapperElement)\n\t\tmenuElement.appendChild(unsendThreadMessagesButton)\n\t\tmenuElement.appendChild(statusElement)\n\t\troot.appendChild(menuElement)\n\t\tconst ui = new OSD(document, root, overlayElement, menuElement, unsendThreadMessagesButton, statusElement)\n\t\tdocument.addEventListener(\"keydown\", (event) => ui.#onWindowKeyEvent(event)) // TODO test\n\t\tdocument.addEventListener(\"keyup\", (event) => ui.#onWindowKeyEvent(event)) // TODO test\n\t\tunsendThreadMessagesButton.addEventListener(\"click\", (event) => ui.#onUnsendThreadMessagesButtonClick(event))\n\t\tui._mutationObserver = new MutationObserver((mutations) => ui.#onMutations(ui, mutations))\n\t\tui._mutationObserver.observe(document.body, { childList: true }) // TODO test\n\t\tunsendThreadMessagesButton.dataTextContent = unsendThreadMessagesButton.textContent\n\t\tunsendThreadMessagesButton.dataBackgroundColor = unsendThreadMessagesButton.style.backgroundColor\n\t\treturn ui\n\t}\n\n\t/**\n\t *\n\t * @param {string} text\n\t */\n\tonStatusText(text) {\n\t\tthis.statusElement.textContent = text\n\t}\n\n\tasync #startUnsending() {\n\t\t;[...this.menuElement.querySelectorAll(\"button\")].filter(button => button !== this.unsendThreadMessagesButton).forEach(button => {\n\t\t\tbutton.style.visibility = \"hidden\"\n\t\t\tbutton.disabled = true\n\t\t})\n\t\tthis.overlayElement.style.display = \"\"\n\t\tthis.overlayElement.focus()\n\t\tthis.unsendThreadMessagesButton.textContent = \"Stop processing\"\n\t\tthis.unsendThreadMessagesButton.style.backgroundColor = \"#FA383E\"\n\t\tthis.statusElement.style.color = \"white\"\n\t\tthis._mutationObserver.disconnect()\n\t\ttry {\n\t\t\tawait this.strategy.run()\n\t\t} catch(error) {\n\t\t\tconsole.error(error)\n\t\t\tif(this.strategy.isRunning()) {\n\t\t\t\tthis.strategy.stop()\n\t\t\t}\n\t\t\tthis.statusElement.innerHTML = `<span style=\"color: red\">An error occured, <a href=\"https://github.com/thoughtsunificator/instagram-dm-unsender/issues/new?template=bug_report.md\">please open an issue</a></span>`\n\t\t} finally {\n\t\t\tthis.#onUnsendingFinished()\n\t\t}\n\t}\n\n\t/**\n\t *\n\t * @param {OSD} ui\n\t */\n\t#onMutations(ui) {\n\t\tif(ui.root.ownerDocument.querySelector(\"[id^=mount] > div > div > div\") !== null && ui) {\n\t\t\tif(this._mutationObserver) {\n\t\t\t\tthis._mutationObserver.disconnect()\n\t\t\t}\n\t\t\tthis._mutationObserver = new MutationObserver(ui.#onMutations.bind(this, ui))\n\t\t\tthis._mutationObserver.observe(ui.root.ownerDocument.querySelector(\"[id^=mount] > div > div > div\"), { childList: true, attributes: true })\n\t\t}\n\t\tif(this.window.location.pathname.startsWith(\"/direct/t/\")) {\n\t\t\tif(!this.strategy.isRunning()) {\n\t\t\t\tthis.strategy.reset()\n\t\t\t}\n\t\t\tthis.root.style.display = \"\"\n\t\t} else {\n\t\t\tthis.root.style.display = \"none\"\n\t\t\tif(this.strategy.isRunning()) {\n\t\t\t\tthis.strategy.stop()\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t *\n\t * @param {OSD} ui\n\t * @param {Event} event\n\t */\n\t#onUnsendThreadMessagesButtonClick() {\n\t\tif(this.strategy.isRunning()) {\n\t\t\tconsole.debug(\"User asked for messages unsending to stop\")\n\t\t\tthis.strategy.stop()\n\t\t\tthis.#onUnsendingFinished()\n\t\t} else {\n\t\t\tconsole.debug(\"User asked for messages unsending to start; UI interaction will be disabled in the meantime\")\n\t\t\tthis.#startUnsending()\n\t\t}\n\t}\n\n\t/**\n\t *\n\t * @param {Event} event\n\t * @returns {boolean}\n\t */\n\t#onWindowKeyEvent(event) {\n\t\tif(this.strategy.isRunning()) {\n\t\t\tconsole.log(\"User interaction is disabled as the unsending is still running; Please stop the execution first.\")\n\t\t\tevent.stopImmediatePropagation()\n\t\t\tevent.preventDefault()\n\t\t\tevent.stopPropagation()\n\t\t\tthis.overlayElement.focus()\n\t\t\treturn false\n\t\t}\n\t}\n\n\t#onUnsendingFinished() {\n\t\tconsole.debug(\"render onUnsendingFinished\")\n\t\t;[...this.menuElement.querySelectorAll(\"button\")].filter(button => button !== this.unsendThreadMessagesButton).forEach(button => {\n\t\t\tbutton.style.visibility = \"\"\n\t\t\tbutton.disabled = false\n\t\t})\n\t\tthis.unsendThreadMessagesButton.textContent = this.unsendThreadMessagesButton.dataTextContent\n\t\tthis.unsendThreadMessagesButton.style.backgroundColor = this.unsendThreadMessagesButton.dataBackgroundColor\n\t\tthis.overlayElement.style.display = \"none\"\n\t\tthis.statusElement.style.color = \"\"\n\t\tthis._mutationObserver.observe(this._document.body, { childList: true }) // TODO test\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {Document}\n\t */\n\tget document() {\n\t\treturn this._document\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {Window}\n\t */\n\tget window() {\n\t\treturn this._document.defaultView\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {HTMLDivElement}\n\t */\n\tget root() {\n\t\treturn this._root\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {HTMLDivElement}\n\t */\n\tget overlayElement() {\n\t\treturn this._overlayElement\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {HTMLDivElement}\n\t */\n\tget menuElement() {\n\t\treturn this._menuElement\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {HTMLButtonElement}\n\t */\n\tget unsendThreadMessagesButton() {\n\t\treturn this._unsendThreadMessagesButton\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {HTMLDivElement}\n\t */\n\tget statusElement() {\n\t\treturn this._statusElement\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {UnsendStrategy}\n\t */\n\tget strategy() { // TODO move out\n\t\treturn this._strategy\n\t}\n\n\t/**\n\t * @readonly\n\t * @type {IDMU}\n\t */\n\tget idmu() {\n\t\treturn this._idmu\n\t}\n\n}\n\nexport default OSD\n","/** @module main Main module */\n\nimport OSD from \"./osd/osd.js\"\n\n/**\n * @param {Window} window\n */\nexport function main(window) {\n\tOSD.render(window)\n}\n\nif(typeof window !== \"undefined\") {\n\tmain(window)\n}\n"],"names":[],"mappings":"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"}