tooltip {
  -moz-appearance: auto;
 
  border-radius: 3px !important;
  border: 1px solid #AEAEAE;
  padding: 2px 3px;
  font-family: system !important;
  font-size: 17px !important;
  max-width: 40em !important;
  font-widht: 900 !important;
   
  background: linear-gradient(#FFFFDB, yellow) !important; 
  color: #000 !important;
  font-style: italic !important;
  font: message-box;
}

Uncaught (in promise) TypeError: this.loader is undefined
    get console/this.console< chrome://custombuttons-context/content/button.js?windowId=Firefox&id=custombuttons-button25@init line 1 > Function:165
    handleEvent chrome://custombuttons-context/content/button.js?windowId=Firefox&id=custombuttons-button25@init line 1 > Function:153
    handleEvent chrome://custombuttons/content/contextBuilder.js:74

/*Initialization Code*/
({
	title: "Консоль браузера",
  url: "chrome://devtools/content/webconsole/index.html",

	icon: "chrome://devtools/skin/images/tool-webconsole.svg",
	init() {
		var trg = document.getElementById("browser");
		trg && addEventListener("DOMContentLoaded", this, false, trg);
		var id = "viewBrowserConsoleSidebar";

		var menuitem = this.element("menuitem", {
			type: "checkbox",
			label: this.title,
			id: "menu_browserConsoleSidebar",
			oncommand: `SidebarUI.toggle("${id}");`
		}, document.getElementById("viewSidebarMenu"));

		var btn = this.element("toolbarbutton", {
			type: "checkbox",
			label: this.title,
			id: "sidebar-switcher-browserConsole",
			oncommand: `SidebarUI.show("${id}");`,
			class: "subviewbutton subviewbutton-iconic"
		});
		document.querySelector(
			'toolbarbutton[id^="sidebar-switcher-"] + toolbarseparator'
		).before(btn);

		SidebarUI.sidebars.set(id, {
			url: this.url,
			buttonId: btn.id,
			title: this.title,
			menuId: menuitem.id
		});
		SidebarUI.isOpen && SidebarUI.currentID == id && SidebarUI.selectMenuItem(id);

		var popupset = this.popupset = this.element("popupset", {
			id: `CB${_id.slice(20)}-browserConsole-popupset`
		}, document.documentElement);

		var css = `\
			#${btn.id} > .toolbarbutton-icon,
			#sidebar-box[sidebarcommand="${id}"] > #sidebar-header > #sidebar-switcher-target > #sidebar-icon {
				list-style-image: url(${this.icon});
			}`;
		var str = (cbu.cb || "") + "data:text/css," + encodeURIComponent(css), type = windowUtils.USER_SHEET;
		windowUtils.loadSheetUsingURIString(str, type);

		addDestructor(() => {
			SidebarUI.sidebars.delete(id);
			btn.remove(); menuitem.remove(); popupset.remove();
			windowUtils.removeSheetUsingURIString(str, type);
		});
		parseInt(Services.appinfo.platformVersion) < 73 
			&& "insertFTLIfNeeded" in MozXULElement
			&& MozXULElement.insertFTLIfNeeded("toolkit/main-window/editmenu.ftl");

		self.onclick = e => {
			if (e.button == 2) return;
			if (!e.button && !e.shiftKey) return SidebarUI.toggle(id);
			var st = gBrowser.selectedTab, tab;
			if (!e.ctrlKey) tab = gBrowser.visibleTabs.find(tab => {
				var br = gBrowser.getBrowserForTab(tab);
				return br.currentURI.spec == this.url || (
					"_cachedCurrentURI" in br
					&& br._cachedCurrentURI.spec == this.url
				)
			});
			if (tab == st) return;
			if (!tab) tab = gBrowser.addTrustedTab(this.url);
			gBrowser.moveTabTo(tab, st._tPos + 1);
			gBrowser.selectedTab = tab;
		}
		for(var br of gBrowser.browsers) {
			if (br.currentURI.spec != this.url) continue;
			var doc = br.contentDocument;
			if (doc && (
				doc.readyState == "complete" ||
				doc.readyState == "interactive"
			))
				doc.querySelector(
					"main#app-wrapper,div#output-container"
				).childElementCount
					? this.defineDocPopupset(doc)
					: this.handleEvent({target: doc});
		}
		if (!btn.hasAttribute("checked")) return;
		var doc = SidebarUI.browser.contentDocument;
		if (doc.documentURI != this.url) btn.doCommand();
		else if (doc.readyState == "complete") this.defineDocPopupset(doc);
	},
	defineDocPopupset(doc) {
		this.definePopupset(
			doc.querySelector("popupset") ||
			doc.documentElement.appendChild(doc.createXULElement("popupset"))
		);
	},
	get definePopupset() {
		var append = customElements.get("menuitem")
			? popup => {
				this.popupset.appendChild(popup);
				popup.setAttribute("oncommand", "event.target.cmd()");
				for(var node of [...popup.querySelectorAll("menuitem")]) {
					var menuitem = document.importNode(node, true);
					menuitem.cmd = Services.els.getListenerInfoFor(node)
						.find(inf => inf.type == "command").listenerObject;
					popup.replaceChild(menuitem, node);
				}
				return popup;
			}
			: this.popupset.appendChild.bind(this.popupset);

		delete this.definePopupset;
		return this.definePopupset = popupset => popupset.appendChild = append;
	},
	lss: Services.scriptloader.loadSubScript,
	async handleEvent({target: doc}) {
		if (!doc || doc.documentURI != this.url) return;

		var win = doc.defaultView;
		if (
			win.docShell.name == "toolbox-panel-iframe-webconsole" ||
			doc.DOMContentLoadedEventHandled
		)
			return;
		doc.DOMContentLoadedEventHandled = true;
		"custombuttonsConsole" in win || this.lss(
			"chrome://custombuttons/content/consoleOverlay.js", win
		);
		var cw = win.isChromeWindow, bc;
		if (!cw) {
			if (doc.visibilityState == "hidden") {
				var {focus} = win;
				win.focus = () => win.focus = focus;
			}
			doc.title = this.title;
			var link = doc.createElement("link");
			link.setAttribute("rel", "shortcut icon");
			link.setAttribute("href", this.icon);
			doc.head.prepend(link);

			var br = win.docShell.chromeEventHandler;
			var cmAttr = br.getAttribute("contextmenu");
			cmAttr && br.removeAttribute("contextmenu");
			win.onbeforeunload = () => {
				if (bc) bc.chromeWindow = {close() {}};
				cmAttr && br.setAttribute("contextmenu", cmAttr);
			}
		}
		bc = await this.console(win);
	},
	get console() {
		// Bug 1579090 - WebConsole should handle ObjectFront when needed (for non-primitive Console API args + Evaluation results) (Firefox 73+)
		https://bugzilla.mozilla.org/show_bug.cgi?id=1579090
		var vers = parseInt(Services.appinfo.platformVersion);
		this.bug1579090 = vers > 73 || (vers == 73 && !(
			"_setCurrentURI" in gBrowser.selectedBrowser // https://bugzil.la/1431214
		));
		delete this.console;
		return this.console = this.bug1579090 ? async win => {
			//await this.loader.bcm._browserConsoleInitializing;
			var key = "CBBrowserConsolePromise", {wins} = this.loader;
			win[key] = win.Object.create(null);
			win[key].promise = new win.Promise(resolve => win[key].resolve = resolve);
			win[key].destroy = () => {
				win[key].resolve();
				delete win[key];
				wins.splice(wins.indexOf(win), 1);
			}
			wins.unshift(win);
			wins.length > 1 && await wins[1][key].promise;

			var bc = await new this.loader.console(win).toggleBrowserConsole();
			win[key].destroy();
			return bc;

		} : async win => {
			this.loader.Services.ww.wins.push(win);
			return await new this.loader.HUDService().toggleBrowserConsole();
		}
	},
	get loader() {
		delete this.loader;
		var url = "resource://devtools/shared/Loader.jsm";
		if (this.bug1579090) {
			var g = Cu.import(url, {}), key = "CBBrowserConsoleLoader";
			addDestructor(reason => reason[5] == e && key in g && g[key].destroy());
			if (key in g) return this.loader = g[key];
			var {BrowserConsoleManager} = g.require(
				"devtools/client/webconsole/browser-console-manager"
			);
			return this.loader = g[key] = {
				wins: [],
				bcm: BrowserConsoleManager,
				console: class extends BrowserConsoleManager.constructor {
					constructor(win) {
						super();
						this.win = win;
					}
					openWindow() {
						var {win} = this;
						win.addEventListener("unload", () => {
							win.CBBrowserConsolePromise &&
								win.CBBrowserConsolePromise.destroy();
							this.closeBrowserConsole.call(this);
						}, {once: true});
						delete this.win;
						return win;
					}
				},
				destroy() {
					this.wins = null;
					delete g[key];
				}
			};
		}
		var id = _id + "-browser-console";
		url += "?" + id;
		var loader = {exports: {}}, nsvo = Cu.import(url, loader);
		addDestructor(reason => reason[5] == "e" && Cu.unload(url));

		if (id in nsvo) return this.loader = nsvo[id];

		var dir = "resource://devtools/client/webconsole/";
		try {
			this.lss(dir + "hudservice.js", loader);
		} catch(ex) {
			// Bug 1570320 - Rename hudservice.js into browser-console-manager.js (Firefox 70+)
			// https://bugzilla.mozilla.org/show_bug.cgi?id=1570320
			this.lss(dir + "browser-console-manager.js", loader);
			this.lss("data:,this.HUDService=BrowserConsoleManager", loader);
		}
		var e = new CustomEvent("DOMContentLoaded", {bubbles: false}), ww = loader.Services.ww;
		loader.Services.ww = Cu.getGlobalForObject(nsvo).Object.create(ww, {
			wins: {value: []},
			openWindow: {value: function() {
				var win = this.wins.shift();
				win.setTimeout(() => win.dispatchEvent(e), 0);
				return win;
			}}
		});
		return this.loader = nsvo[id] = loader;
	},
	element(name, attrs, parent) {
		var node = document.createXULElement(name);
		for(var attr in attrs) node.setAttribute(attr, attrs[attr]);
		parent && parent.append(node);
		return node;
	}
}).init();
this.tooltipText = "Консоль браузера" +"\n"+"\n"+
                   "ЛКМ: В боковой панели" +"\n"+
                   "СКМ: В новой вкладке" +"\n"+
                   "ПКМ: Стандартное меню "

var clickInterval = 5*60;
var intervals = [
	10, 15, 30, 60, 3*60,/* 5*60,*/ 15*60, 30*60, 60*60,
];
var name = "TreeStyleTabAutoReloader";
var addonId = "treestyletab@piro.sakura.ne.jp";
var sfx = "ucf-tst-tab-autoreload", id = `extension:${addonId}:${sfx}`;
var sheets = {
	def(name, css) {
		Object.defineProperty(this, name, {configurable: true, get() {
			delete this[name]; return this[name] = this.pre(name, css);
		}});
	},
	pre(name, css) {
		var ios = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
		var rph = ios.getProtocolHandler("resource").QueryInterface(Ci.nsIResProtocolHandler);
		var sss = Cc["@mozilla.org/content/style-sheet-service;1"].getService(Ci.nsIStyleSheetService);
		var type = "USER_SHEET";
		return (this.pre = (name, css) => {
			var subst = "tst-autoreload-stylesheet-" + name;
			rph.setSubstitution(subst, ios.newURI("data:text/css," + encodeURIComponent(css)));
			return [sss.preloadSheet(ios.newURI(`resource://${subst}/`), sss[type]), Ci.nsIDOMWindowUtils[type]];
		})(name, css);
	}
};
if (!ChromeUtils.domProcessChild.childID) {
	var EXPORTED_SYMBOLS = [name + "Parent"];

	var ep = "resource://gre/modules/ExtensionParent.jsm";
	var manager = ChromeUtils.import(ep).ExtensionParent.apiManager;
	var tt = manager.global.tabTracker;
	var ss = "resource:///modules/sessionstore/SessionStore.jsm";
	ss = ChromeUtils.import(ss).SessionStore;
	var gsec = tab => ss.getCustomTabValue(tab, id);

	var webExt, addonUUID;
	
	var waitAddon = (e, isAppShutdown) => isAppShutdown || (
		webExt = null, manager.on("ready", onReady)
	);
	var onReady = (e, addon) => {
		if (addon.id != addonId) return;
		manager.off("ready", onReady);
		addon.once("shutdown", waitAddon);
		onAddon(addon);				
	}
	var onAddon = addon => {
		webExt = addon;
		if (addonUUID == addon.uuid) return;

		addonUUID && ChromeUtils.unregisterWindowActor(name);
		ChromeUtils.registerWindowActor(name, {
			remoteTypes: ["extension"],
			parent: {moduleURI: __URI__},
			messageManagerGroups: ["webext-browsers"],
			child: {moduleURI: __URI__, events: {pageshow: {}}},
			matches: [`moz-extension://${addonUUID = addon.uuid}/sidebar/sidebar.html?*`]
		});
	}
	var format = sec => {
		var map = new Map();
		// resource://gre/modules/PluralForm.jsm
		var f = n => n % 10 == 1 && n % 100 != 11 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2;
		var hh = ["", "а", "ов"], ms = ["а", "ы", ""];
		return (format = sec => {
			var res = map.get(sec = +sec);
			if (!res) {
				var num, arr = [];
				if ((num = Math.floor(sec / 3600)) > 0)
					sec -= num * 3600,
					arr.push(`${num} час${hh[f(num)]}`);
				if ((num = Math.floor(sec / 60)) > 0)
					sec -= num * 60,
					arr.push(`${num} минут${ms[f(num)]}`);
				sec > 0 && arr.push(`${sec} секунд${
					sec > Math.floor(sec) ? "ы" : ms[f(sec)]
				}`);
				map.set(sec, res = arr.join(" "));
			}
			return res;
		})(sec);
	}
	var hasDef = intervals.includes(clickInterval);
	hasDef || intervals.push(clickInterval);
	sheets.def("sb", `
		#context_autoreloadTab:not([checked]) > .menu-iconic-left,${
			hasDef ? "" : "\n\t\t#context_autoreloadTab[checked][def=true] > menupopup > :nth-child(2),"
		}
		#context_autoreloadTab:not([checked]) > menupopup > :first-child {
			display: none !important;
		}
		#context_autoreloadTab[checked] > .menu-iconic-left > image {
			fill: currentColor !important;
			-moz-context-properties: fill !important;
			list-style-image: url("chrome://global/skin/icons/check.svg") !important;
		}
	`);
	clickInterval = String(clickInterval);

	var sym = Symbol(name);
	var TreeStyleTabAutoReloaderParent = class extends JSWindowActorParent {
		actorCreated() {
			var win = this.browsingContext.embedderElement.ownerGlobal;
			var mo = win[sym];
			if (!mo) {
				win.windowUtils.addSheet(...sheets.sb);
				mo = win[sym] = new win.MutationObserver(this.handleMutations);
				var popup = win.document.getElementById("contentAreaContextMenu");
				mo.obs = mo.observe.bind(mo, popup, {childList: true});
				mo.win = win;
			}
			((mo.actor = this).mo = mo).obs();
		}
		didDestroy() {
			this.mo.disconnect();
		}
		get menu() {
			var value = this.mo.menu;
			if (!value) {
				value = this.mo.win.MozXULElement.parseXULToFragment(
					`<menu id="context_autoreloadTab"
						class="menu-iconic"
						onclick="if (event.target == this) linkedObject.click(this);"
					>
						<menupopup oncommand="parentNode.linkedObject.cmd(event);"/>
					</menu>`
				);
				(value = this.mo.menu = value.firstChild).remove();
				value.linkedObject = this;
				(value.popup = value.firstChild).initShadowDOM = this.initShadowDOM;
			}
			return Object.defineProperty(this, "menu", {value}).menu;
		}
		initShadowDOM() {
			delete this.initShadowDOM;
			this.initShadowDOM();

			var df = this.ownerGlobal.MozXULElement.parseXULToFragment(
				`<menuitem closemenu="single" label="Не перезагружать"
					oncommand="event.stopPropagation(); parentNode.parentNode.click();"/>
				<menuitem label="Другой…"
					oncommand="event.stopPropagation(); parentNode.parentNode.linkedObject.prompt();"/>
				<menuseparator/>`
			);
			var doc = this.ownerDocument;

			for(var sec of intervals) {
				var menuitem = doc.createXULElement("menuitem");
				menuitem.setAttribute("type", "radio");
				menuitem.setAttribute("closemenu", "single");
				menuitem.setAttribute("value", sec);
				menuitem.setAttribute("label", format(sec));
				df.append(menuitem);
			}
			hasDef || df.firstChild.after(df.lastChild);
			this.append(df);
			this.parentNode.linkedObject.updMenupopup(this);
			this.setAttribute("onpopupshowing", "parentNode.linkedObject.updMenupopup(this);");
		}
		handleMutations(muts) {
			var cm = this.win.gContextMenu;
			if (cm) for(var mut of muts) for(var node of mut.addedNodes)
				if (node.id == "treestyletab_piro_sakura_ne_jp-menuitem-_context_duplicateTab") {
					var {tabId} = cm.contentData.webExtContextData;
					var tab = tt.getTab(tabId);
					//if (tab?.linkedBrowser.currentURI.scheme.startsWith("http")) {
					if (tab) {
						var {menu} = this.actor;
						menu.tabId = tabId;
						node.after(menu);
						this.actor.maybeSetLabel(tab);
						webExt.apiManager.global.gMenuBuilder.itemsToCleanUp.add(menu);
					}
					break;
				}
		}
		maybeSetLabel(tab) {
			var sec = gsec(tab);
			var has = this.menu.hasAttribute("checked");
			if (Boolean(sec) ^ has)
				has = !has, this.menu.toggleAttribute("checked");

			var curr = has && sec;
			curr !== this.menu.sec && this.setLabel(curr);
		}
		setLabel(sec) {
			this.menu.setAttribute("label", (this.menu.sec = sec)
				? `Интервал перезагрузки:   ${format(sec)}`
				: "Задать интервал перезагрузки"
			);
			hasDef || this.menu.setAttribute("def", sec == clickInterval);
		}
		click(menu) {
			var {tabId} = menu;
			var has = menu.toggleAttribute("checked");
			has
				? this.initTab(tabId, clickInterval)
				: this.destroyTab(tabId);

			var w = menu.clientWidth;
			this.setLabel(has && clickInterval);

			if (menu.popup.state == "open")
				this.updMenupopup(menu.popup),
				menu.clientWidth != w && menu.ownerGlobal.setTimeout(this.move, 50, menu);
		}
		cmd(e) {
			var {value} = e.target;
			if (value == this.menu.sec) return;

			var {tabId} = this.menu;
			this.setLabel(value);

			if (this.menu.hasAttribute("checked"))
				this.changeInterval(tt.getTab(tabId), value);
			else
				this.menu.toggleAttribute("checked"),
				this.initTab(tabId, value);
		}
		changeInterval(tab, sec) {
			var win = tab.ownerGlobal;
			win.clearInterval(tab.getAttribute(sfx));
			ss.setCustomTabValue(tab, id, sec);
			tab.setAttribute(sfx, win.setInterval(bro.reload, sec * 1e3, tab));
		}
		async prompt(val) {
			var {menu} = this, {sec} = menu;
			var {prompt} = menu.ownerGlobal.Services;
			var res = await prompt.asyncPrompt(
				null, prompt.MODAL_TYPE_WINDOW,
				val ? "ЕЩЁ РАЗ:" : "Задать интервал обновления",
				"Введите число секунд авто-обновления",
				val || sec || clickInterval, null, null
			);
			if (!res.get("ok")) return;

			var val = res.get("value");
			if (!val) return;
			if (!isFinite(val)) return this.prompt(val);

			var {tabId} = menu, val = String(Math.round(val) || 1);
			sec ? this.changeInterval(tt.getTab(tabId), val) : this.initTab(tabId, val);
		}
		move(menu) {
			menu.popup.moveToAnchor(menu, "end_before");
		}
		updMenupopup(popup) {
			var old = popup.querySelector("[checked=true]");
			var {sec} = this.menu;
			var cur = sec && popup.querySelector(`[value="${sec}"]`);
			if (old != cur)
				old?.removeAttribute("checked"),
				cur && cur.setAttribute("checked", true);
		}
		initTab(tabId, sec, skipSet) {
			bro.initTab(tt.getTab(tabId), sec);
			this.sendAsyncMessage(tabId, true);
		}
		destroyTab(tabId) {
			bro.destroyTab(tt.getTab(tabId));
			this.sendAsyncMessage(tabId);
		}
		receiveMessage(msg) {
			msg.name && bro.destroyTab(tt.getTab(+msg.name));
		}
	}
	var bro = {
		async observe(win) {
			var tc = win.document.getElementById("tabbrowser-tabs");
			var tp = win.document.getElementById("tabbrowser-tabpanels")
			var types = ["EndSwapDocShells", "TabClose", "SSTabRestored"];

			var destructor = (meth = "removeEventListener") => types.forEach(
				(type, ind) => (ind ? tc : tp)[meth](type, this, ind == 0)
			);
			destructor("addEventListener");

			win.ucf_custom_script_win[id] = {destructor};
			win.ucf_custom_script_win.unloadlisteners.push(id);

			await ss.promiseAllWindowsRestored;
			for(var tab of win.gBrowser.tabs)
				tab.linkedPanel || this.maybeInitTab(tab);
		},
		maybeInitTab(tab) {
			var sec = gsec(tab);
			sec && this.initTab(tab, sec, true);
		},
		handleEvent(e) {
			this[e.type](e);
		},
		reload(tab) {
			tab.ownerGlobal.gBrowser.reloadTab(tab);
		},
		initTab(tab, sec, skipSet) {
			skipSet || ss.setCustomTabValue(tab, id, sec);
			tab.setAttribute(sfx, tab.ownerGlobal.setInterval(this.reload, sec * 1e3, tab));
		},
		destroyTab(tab) {
			tab.ownerGlobal.clearInterval(tab.getAttribute(sfx));
			ss.deleteCustomTabValue(tab, id);
			tab.removeAttribute(sfx);
		},
		TabClose(e) {
			var intervalId = e.target.getAttribute(sfx);
			if (!intervalId) return;
			e.target.ownerGlobal.clearInterval(intervalId);

			var tab = e.detail.adoptedBy;
			tab && this.initTab(tab, gsec(e.target));
		},
		SSTabRestored(e) {
			var tab = e.target;
			tab.hasAttribute(sfx) || this.maybeInitTab(tab);
		},
		async EndSwapDocShells(e) {
			var br = e.detail, trg = e.target, win = br.ownerGlobal;
			await new Promise(win.requestAnimationFrame);

			if (!win.closed) return;
			var tab = win.gBrowser.getTabForBrowser(br);
			if (!tab) return;

			var sec = gsec(tab);
			if (sec)
				tab = trg.ownerGlobal.gBrowser.getTabForBrowser(trg),
				tab.hasAttribute(sfx) || this.initTab(tab, sec);
		}
		
	};
	var topic = "browser-delayed-startup-finished";
	var obs = Cc["@mozilla.org/observer-service;1"].getService(Ci.nsIObserverService);

	obs.addObserver(bro, topic);
	obs.addObserver(function quit(s, t) {
		obs.removeObserver(quit, t);
		obs.removeObserver(bro, topic);
	}, "quit-application-granted");

	var policy = WebExtensionPolicy.getByID(addonId);
	if (policy)
		onAddon(policy.extension),
		policy.extension.once("shutdown", waitAddon);
	else
		waitAddon();

} else {
	var EXPORTED_SYMBOLS = [name + "Child"];

	sheets.def("tst", `
		:root {
			--ar-ind-width: 22px;
		}
		.autoreload-indicator {
			opacity: .6 !important;
			height: 100% !important;
			fill: currentColor !important;
			-moz-context-properties: fill !important;
			min-width: var(--ar-ind-width) !important;
			background: no-repeat center/60% url("chrome://browser/skin/reload.svg") !important;
		}
		.autoreload-indicator:hover {
			opacity: 1 !important;
		}
		tab-item-substance[autoreload] > .extra-items-container.front {
			right: calc(var(--tab-label-end-offset) + var(--ar-ind-width)) !important;
		}
		tab-item.faviconized .autoreload-indicator {
			min-width: 12px !important;
			background-size: 100% !important;
		}
		tab-item.faviconized > tab-item-substance[autoreload] {
			padding-inline-start: 0 !important;
		}
	`);
	var TreeStyleTabAutoReloaderChild = class extends JSWindowActorChild {
		async handleEvent(e) {
			this.sendAsyncMessage("");
			this.stopReload = this.stopReload.bind(this);

			var win = e.target.ownerGlobal;
			win.windowUtils.addSheet(...sheets.tst);

			var opts = {childList: true};
			var allTabs = e.target.getElementById("all-tabs");

			await new Promise(resolve => {
				var mo = new win.MutationObserver(
					() => allTabs.firstElementChild && resolve(mo.disconnect())
				);
				mo.observe(allTabs, opts);
			});
			this.mo = new win.MutationObserver(muts => {
				for(var mut of muts) for(var node of mut.addedNodes) this.check(node);
			});
			var trg = allTabs.firstElementChild;
			this.mo.observe(trg, opts);
			for(var node of trg.children) this.check(node);
		}
		check(node) {
			node.nodeName == "TAB-ITEM" && this.onTab(node);
		}
		async onTab(tab, tabId) {
			var subs = tab.querySelector("tab-item-substance");
			var win = tab.ownerDocument.defaultView.wrappedJSObject;
			if (!tabId) {
				if (subs.hasAttribute("autoreload"))
					subs.removeAttribute("autoreload"),
					subs.querySelector(".autoreload-indicator")?.remove();

				var {tabId} = subs.dataset;
				var sec = await win.browser.sessions.getTabValue(+tabId, sfx);
				if (!sec) return;
			}
			subs.toggleAttribute("autoreload", true);
			var ind = win.document.createElement("span");
			ind.className = "autoreload-indicator";
			ind.title = "Остановить перезагузку";
			ind.tabId = tabId;
			ind.onmousedown = this.stopReload;
			subs.querySelector("tab-closebox").before(ind);
		}
		stopReload(e) {
			if (e.button) return;
			e.stopImmediatePropagation();
			var trg = e.target.wrappedJSObject;
			this.sendAsyncMessage(trg.tabId);
			this.removeIndicator(trg);
		}
		removeIndicator(ind) {
			ind.parentNode.removeAttribute("autoreload");
			ind.remove();
		}
		receiveMessage(msg) {
			var tab = this.contentWindow.document.getElementById("tab-" + msg.name);
			if (tab) msg.data
				? this.onTab(tab, msg.name)
				: this.removeIndicator(tab.querySelector(".autoreload-indicator"));
		}
		didDestroy() {
			this.mo?.disconnect();
		}
	}
}