Beiträge von Endor

// ==UserScript==
// @name           SaveUserChromeJS.uc.js
// @author         ywzhaiqi
// @description    UC-Skripte wie Greasemonkey Skripte speichern
// @include        main
// @charset        UTF-8
// @version        0.4b
// @homepageURL    https://github.com/ywzhaiqi/userChromeJS/tree/master/SaveUserChromeJS
// @reviewURL      http://bbs.kafan.cn/thread-1590873-1-1.html
// ==/UserScript==

(function() {

// Benachrichtigung nach dem Speichern des Skriptes, aktivieren？
var notificationsAfterInstall = true;

// Soll das Skript nach dem Speichern automatisch geladen werden (kein Start erforderlich)? 
// Es werden nur einige .uc.js Skripte unterstützt. Die meisten Skripte benötigen einen Neustart.
var runWithoutRestart = false;


let { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
if (!window.Services) Cu.import("resource://gre/modules/Services.jsm");

if(typeof window.saveUserChromeJS != "undefined"){
    window.saveUserChromeJS.uninit();
    delete window.saveUserChromeJS;
}

const RE_USERCHROME_JS = /\.uc(?:-\d+)?\.(?:js|xul)$|userChrome\.js$/i;
const RE_CONTENTTYPE = /text\/html/i;

var ns = window.saveUserChromeJS = {
    _menuitem: null,
    get SCRIPTS_FOLDER() {
        delete this.SCRIPTS_FOLDER;
        return this.SCRIPTS_FOLDER = Services.dirsvc.get("UChrm", Ci.nsILocalFile);
    },

    init: function() {
        Services.obs.addObserver(this, "content-document-global-created", false);

        // add contentAreaContextMenu
        var contextMenu = $("contentAreaContextMenu");
        var menuitem = this.createMenuitem();
        contextMenu.insertBefore(menuitem, contextMenu.firstChild);
        contextMenu.addEventListener("popupshowing", this, false);

        this._menuitem = menuitem;
    },
    uninit: function(){
        Services.obs.removeObserver(this, "content-document-global-created");

        if(this._menuitem){
            this._menuitem.parentNode.removeChild(this._menuitem);
        }

        $("contentAreaContextMenu").removeEventListener("popupshowing", this, false);
    },
    handleEvent: function(event){
        switch(event.type){
            case "popupshowing":
                if (event.target != event.currentTarget) return;
                if(gContextMenu.onLink){
                    this._menuitem.hidden = !RE_USERCHROME_JS.test(gContextMenu.linkURL);
                }else{
                    this._menuitem.hidden = true;
                }
                break;
        }
    },
    observe: function(aSubject, aTopic, aData) {
        switch (aTopic) {
            case "content-document-global-created":
                let safeWin = aSubject;
                let chromeWin = this.getBrowserForContentWindow(safeWin).wrappedJSObject;
                if (!chromeWin) return;

                let gBrowser = chromeWin.gBrowser;
                if (!gBrowser) return;

                let lhref = safeWin.location.href;
                if(lhref.startsWith("view-source")) return;

                // Show the scriptish install banner if the user is navigating to a .user.js
                // file in a top-level tab.
                if (safeWin === safeWin.top && RE_USERCHROME_JS.test(lhref) && !RE_CONTENTTYPE.test(safeWin.document.contentType)) {
                    safeWin.setTimeout(function(){
                        ns.showInstallBanner(gBrowser.getBrowserForDocument(safeWin.document));
                    }, 500);
                }

                if(safeWin.location.hostname == 'github.com'){
                    safeWin.addEventListener("DOMContentLoaded", function(){
                        ns.github_addButton(safeWin.document);

                        // github verwendet history.pushstate. Die Schaltfläche nach dem Laden der Seite erneut hinzugefügt werden.
                        // 2014-7-15: Firefox 33 (Nightly) stürzt ab, wenn auf ein unsicheres Fenster verwiesen wird. $ Wird referenziert 
                        // Details siehe: https://tieba.baidu.com/f?ct=335675392&tn=baiduPostBrowser&z=3162087505&sc=53663075812#53663075812
                        if (Services.appinfo.version < 33) {
                            ns.github_addListener(safeWin);
                        }                    
                        var sWBrowser = gBrowser.getBrowserForContentWindow(safeWin);
                        if (!sWBrowser.ProgListener) {
                           sWBrowser.ProgListener = {
                              QueryInterface: XPCOMUtils.generateQI(["nsIWebProgressListener", "nsISupportsWeakReference"]),
                              onLocationChange: function() {
                                 safeWin.setTimeout(function() {
                                    ns.github_addButton(safeWin.document);
                                 }, 0);
                              }
                           };
                        };
                        try {
                           sWBrowser.addProgressListener(sWBrowser.ProgListener, Ci.nsIWebProgress.NOTIFY_LOCATION);
                           safeWin.addEventListener('beforeunload', function() {
                              sWBrowser.removeProgressListener(sWBrowser.ProgListener);
                           });
                        } catch(e) { };
                    }, false);
                }

                break;
        }
    },
    createMenuitem: function(){
        var menuitem = $C("menuitem", {
            id: "uc-install-menu",
            label: "Installieren für userChromeJS...",
            accessKey: "I",
            oncommand: "saveUserChromeJS.saveScript(gContextMenu.linkURL)"
        });

        return menuitem;
    },
    showInstallBanner: function(browser) {
        var notificationBox = gBrowser.getNotificationBox(browser);
        var greeting = "Das ist ein userChrome Script. Klicken Sie auf Installieren, um es zu verwenden. Nach dem Speichern im Chrome Ordner bitte einen Neustart durchführen.";
        var btnLabel = "Installieren";

        // Remove existing notifications. Notifications get removed
        // automatically onclick and on page navigation, but we need to remove
        // them ourselves in the case of reload, or they stack up.
        for (var i = 0, child; child = notificationBox.childNodes[i]; i++)
            if (child.getAttribute("value") == "install-userChromeJS")
                notificationBox.removeNotification(child);

        var notification = notificationBox.appendNotification(
            greeting,
            "install-userChromeJS",
            null,
            notificationBox.PRIORITY_WARNING_MEDIUM, [{
                label: btnLabel,
                accessKey: "I",
                popup: null,
                callback: this.saveCurrentScript
            }
        ]);
    },
    github_addButton: function(doc){
        if(doc.getElementById("uc-install-button")) return;

        var rawBtn = doc.getElementById("raw-url");
        if(!rawBtn) return;

        var downURL = rawBtn.href;
        if(!RE_USERCHROME_JS.test(downURL)) return;

        var installBtn = doc.createElement("a");
        installBtn.setAttribute("id", "uc-install-button");
        installBtn.setAttribute("class", "btn btn-sm");
        installBtn.setAttribute("href", downURL);
        installBtn.innerHTML = "Installieren";
        installBtn.addEventListener("click", function(event){
            event.preventDefault();
            ns.saveScript(downURL);
        }, false);

        rawBtn.parentNode.insertBefore(installBtn, rawBtn);
    },
    github_addListener: function(win){
        var script = '\
            (function(){\
                var $ = unsafeWindow.jQuery;\
                if(!$) return;\
                $(document).on("pjax:success", function(){\
                    github_addButton(document);\
                });\
            })();\
        ';
        let sandbox = new Cu.Sandbox(win, {sandboxPrototype: win});
        sandbox.unsafeWindow = win.wrappedJSObject;
        sandbox.document     = win.document;
        sandbox.window       = win;
        sandbox.github_addButton = ns.github_addButton;
        Cu.evalInSandbox(script, sandbox);
    },
    saveCurrentScript: function(event){
        ns.saveScript();
    },
    saveScript: function(url) {
        var win = ns.getFocusedWindow();

        var doc, name, fileName, fileExt, charset;
        if(!url){
            url = win.location.href;
            doc = win.document;
            name = doc.body.textContent.match(/\/\/\s*@name\s+(.*)/i);
            charset = doc.body.textContent.match(/\/\/\s*@charset\s+(.*)/i);
        }else{
            if(url.match(/^https?:\/\/github\.com\/\w+\/\w+\/blob\//)){
                url = url.replace("/blob/", "/raw/");
            }
        }

        name = name && name[1] ? name[1] : decodeURIComponent(url.split("/").pop());
        fileName = name.replace(/\.uc\.(js|xul)$|$/i, ".uc.$1").replace(/\s/g, '_');
        if (fileName.match(/\.uc\.$/i)) {  // Bezeichnung ändern
            var m = url.match(/\.(js|xul)$/);
            if (m)
                fileName += m[1];
        }
        fileExt = name.match(/\.uc\.(js|xul)$/i);
        fileExt = fileExt && fileExt[1] ? fileExt[1] : "js";
        charset = charset && charset[1] ? charset[1] : "UTF-8";

        // https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XUL/Tutorial/Open_and_Save_Dialogs
        var fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
        var err = false;
          try {
             fp.init(window, "", Ci.nsIFilePicker.modeSave);
          } catch(e) {
             fp.init(ns.getMostRecentWindow(), "", Ci.nsIFilePicker.modeSave);
             err = true;
             Application.console.log('SaveUserChromeJS.uc.js - error catched (A)');
          };

        // bei einigen Benutzern (Win7) macht die folgende Zeile bei der Dateinamenvergabe Probleme, ggf. also deaktivieren
        fp.appendFilter("*." + fileExt, "*.uc.js;*.uc.xul");
        fp.appendFilters(Ci.nsIFilePicker.filterAll);
        fp.displayDirectory = ns.SCRIPTS_FOLDER; // nsILocalFile
        fp.defaultExtension = fileExt;
        fp.defaultString = fileName;
        var callbackObj = {
            done: function(res) {
                if (res != fp.returnOK && res != fp.returnReplace) return;

                var persist = Cc["@mozilla.org/embedding/browser/nsWebBrowserPersist;1"].createInstance(Ci.nsIWebBrowserPersist);
                persist.persistFlags = persist.PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION;

                var obj_URI;
                if(doc && fileExt != 'xul'){
                    obj_URI = doc.documentURIObject;
                }else{
                    obj_URI = Services.io.newURI(url, null, null);
                }

                if(notificationsAfterInstall){
                    persist.progressListener = {
                        onProgressChange: function(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress) {
                            if(aCurSelfProgress == aMaxSelfProgress){
                var win1 = err ? ns.getMostRecentWindow() : window;
                                    win1.setTimeout(function(){

                                    ns.showInstallMessage({
                                        fileExt: fileExt,
                                        fileName: fileName,
                                        file: fp.file,
                                        charset: charset
                                    });
                                }, 100);
                            }
                        },
                        onStateChange: function(aWebProgress, aRequest, aStateFlags, aStatus) { }
                    };
                }

                persist.saveURI(obj_URI, null, null, null, null, "", fp.file, null);
            }
        };
        fp.open(callbackObj);
    },
    showInstallMessage: function(info){
        var isRun = (info.fileExt == "js");

        var mainAction, secondActions;
        if(runWithoutRestart && isRun){
            mainAction = {
                label: "Sofort ausführen (ohne Neustart).",
                accessKey: "a",
                callback: function(){
                    ns.runScript(info.file, info.charset);
                }
            };
            secondActions = [{
                label: "Jetzt neu starten",
                accessKey: "s",
                callback: ns.restartApp
            }];
        }else{
            mainAction = {
                label: "Jetzt neu starten",
                accessKey: "s",
                callback: ns.restartApp
            };
            secondActions = null;
        }

        var showedMsg = ns.popupNotification({
            id: "userchromejs-install-popup-notification",
            message: "'" + info.fileName + "' Die Installation ist abgeschlossen.",
            mainAction: mainAction,
            secondActions: secondActions,
            options: {
                removeOnDismissal: true,
                persistWhileVisible: true
            }
        });
    },
    popupNotification: function(details){
        var win = ns.getMostRecentWindow();
        if (win && win.PopupNotifications) {
            win.PopupNotifications.show(
                win.gBrowser.selectedBrowser,
                details.id,
                details.message,
                "",
                details.mainAction,
                details.secondActions,
                details.options);
            return true;
        }

        return false;
    },
    // Unterstützt nur us.js Skripte
    runScript: function(file, charset){
        window.userChrome_js.getScripts();
        if(window.userChromeManager){
            window.userChromeManager.rebuildScripts();
        }

        var dir = file.parent.leafName;
        if(dir.toLowerCase() == 'chrome' || (dir in window.userChrome_js.arrSubdir)){

            let context = {};
            Services.scriptloader.loadSubScript( "file:" + file.path, context, charset || "UTF-8");
        }
    },
    flushCache: function (file) {
        if (file)
             Services.obs.notifyObservers(file, "flush-cache-entry", "");
        else
             Services.obs.notifyObservers(null, "startupcache-invalidate", "");
    },
    getFocusedWindow: function() {
        var win = document.commandDispatcher.focusedWindow;
        try {
         return (!win || win == window) ? content : win;
      } catch(e) {
         Application.console.log('SaveUserChromeJS.uc.js - error catched (B)');
         return (!win || win == window) ? null : win;
      };
    },
    getMostRecentWindow: function(){
        return Services.wm.getMostRecentWindow("navigator:browser")
    },
    getBrowserForContentWindow: function(aContentWindow) {
      return aContentWindow
          .QueryInterface(Ci.nsIInterfaceRequestor)
          .getInterface(Ci.nsIWebNavigation)
          .QueryInterface(Ci.nsIDocShellTreeItem)
          .rootTreeItem
          .QueryInterface(Ci.nsIInterfaceRequestor)
          .getInterface(Ci.nsIDOMWindow)
          .QueryInterface(Ci.nsIDOMChromeWindow);
    },
    restartApp: function() {
        const appStartup = Components.classes["@mozilla.org/toolkit/app-startup;1"].getService(Components.interfaces.nsIAppStartup);

        // Notify all windows that an application quit has been requested.
        var os = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
        var cancelQuit = Components.classes["@mozilla.org/supports-PRBool;1"].createInstance(Components.interfaces.nsISupportsPRBool);
        os.notifyObservers(cancelQuit, "quit-application-requested", null);

        // Something aborted the quit process.
        if (cancelQuit.data) return;

        // Notify all windows that an application quit has been granted.
        os.notifyObservers(null, "quit-application-granted", null);

        // Enumerate all windows and call shutdown handlers
        var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator);
        var windows = wm.getEnumerator(null);
        var win;
        while (windows.hasMoreElements()) {
            win = windows.getNext();
            if (("tryToClose" in win) && !win.tryToClose()) return;
        }
        let XRE = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime);
        if (typeof XRE.invalidateCachesOnRestart == "function") XRE.invalidateCachesOnRestart();
        appStartup.quit(appStartup.eRestart | appStartup.eAttemptQuit);
    }
};


function $(id) document.getElementById(id);
function $C(name, attr) {
    var el = document.createElement(name);
    if (attr) Object.keys(attr).forEach(function(n) el.setAttribute(n, attr[n]));
    return el;
}

function log(arg) Application.console.log("[SaveUserChromeJS]" + arg);

function checkDoc(doc) {
    if (!(doc instanceof HTMLDocument)) return false;
    if (!window.mimeTypeIsTextBased(doc.contentType)) return false;
    if (!doc.body || !doc.body.hasChildNodes()) return false;
    if (doc.body instanceof HTMLFrameSetElement) return false;
    return true;
}


})();


window.saveUserChromeJS.init();

//ScrollTopAndBottom.uc.js
(function() {


let menuitem = document.createXULElement('menuitem');
menuitem.id = 'context-to-top';
menuitem.classList.add('menuitem-iconic');
menuitem.setAttribute('tooltiptext' , '');
menuitem.style.listStyleImage='url("chrome://browser/skin/back.svg")';


menuitem.setAttribute('oncommand' , "ownerGlobal.gBrowser.selectedBrowser.messageManager.loadFrameScript(' data: , content.scrollTo(0,0) ' , false);");
let refItem = document.getElementById('context-reload');
refItem.parentNode.insertBefore(menuitem, refItem);


})();


(function() {


let menuitem = document.createXULElement('menuitem');
menuitem.id = 'context-to-bottom';
menuitem.classList.add('menuitem-iconic');
menuitem.setAttribute('tooltiptext' , '');
menuitem.style.listStyleImage='url("chrome://browser/skin/forward.svg")';
menuitem.setAttribute('oncommand' , "ownerGlobal.gBrowser.selectedBrowser.messageManager.loadFrameScript(' data: , content.scrollTo(0,100000) ' , false);");
let refItem = document.getElementById('context-reload');
refItem.parentNode.insertBefore(menuitem, refItem);


var css = '\
@-moz-document url("chrome://browser/content/browser.xhtml") { \
#context-to-top { \
list-style-image: url("chrome://browser/skin/back.svg");\
transform:rotate(90deg)!important;\
color:#00cd00!important;\
}\
#context-to-top:hover { \
list-style-image: url("chrome://browser/skin/back.svg");\
transform:rotate(90deg)!important;\
color:#008b00!important;\
}\
\
#context-to-bottom{\
list-style-image: url("chrome://browser/skin/forward.svg");\
transform:rotate(90deg)!important;\
color:#00cd00!important;\
}\
#context-to-bottom:hover{\
list-style-image: url("chrome://browser/skin/forward.svg");\
transform:rotate(90deg)!important;\
color:#008b00!important;\
}';
var cssUri = Services.io.newURI('data:text/css,' + encodeURIComponent(css), null, null);
var SSS = Cc['@mozilla.org/content/style-sheet-service;1'].getService(Ci.nsIStyleSheetService);
SSS.loadAndRegisterSheet(cssUri, SSS.AGENT_SHEET);
})();

// ==UserScript==
// @name            UndoCloseTabButton1
// @description        Kürzlich geschlossene Tabs, mit Mittelklick auf Schaltfläche oder freie Stelle in Tableiste, wiederherstellen.
// @version            1.2.5
// @include            main
// @charset            UTF-8
// @note            2019/01/23 Fx66 Problem, bei dem das Klicken in die Tableiste nicht funktionierte - behoben 
// @note            2019/07/04 Fx69
// @note            2019/09/03 Fx70
// @note            2019/12/09 Fx72
// ==/UserScript==
// Schaltfläche wird standardmäßig in die Navigationsleiste eingefügt.
(function() {
    "use strict";

    const useTabbarMiddleClick = false;    
    // Kürzlich geschlossene Tabs mit Mittelklick auf Tableiste oder neuen Tab 
    // Schaltfläche wiederherstellen, aktivieren? ( true = ja false = nein )

    const XULNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";

    window.ucjsUndoCloseTabButtonService = {
        prepareMenu(event) {
            const doc = (event.view && event.view.document) || document;
            const menu = event.originalTarget;
            this.removeChilds(menu);

            // Geschlossene Tabs
            let data = JSON.parse(SessionStore.getClosedTabData(window));
            const tabLength = data.length;

            for (let i = 0; i < tabLength; i++) {
                const item = data[i];
                const m = this.createFaviconMenuitem(doc, item.title, item.image, i, this.undoTab);

                const state = item.state;
                let idx = state.index;
                if (idx == 0)
                    idx = state.entries.length;
                if (--idx >= 0 && state.entries[idx])
                    m.setAttribute("targetURI", state.entries[idx].url);

                menu.appendChild(m);
            }

            // Geschlossenes Fenster 
            data = JSON.parse(SessionStore.getClosedWindowData());
            const winLength = data.length;
            if (winLength > 0) {
                if (tabLength > 0)
                    menu.appendChild(this.$C(doc, "menuseparator"));

                menu.appendChild(this.$C(doc, "menuitem", {
                    disabled:    true,
                    label:        "Geschlossene Fenster"
                }));

                for (let i = 0; i < winLength; i++) {
                    const item = data[i];

                    let title = item.title;
                    const tabsCount = item.tabs.length - 1;
                    if (tabsCount > 0)
                        title += " (他:" + tabsCount + ")";

                    const tab = item.tabs[item.selected - 1];

                    const m = this.createFaviconMenuitem(doc, title, tab.image, i, this.undoWindow);
                    menu.appendChild(m);
                }
            }

            if (tabLength + winLength === 0) {
/*                menu.appendChild(this.$C(doc, "menuitem", {
                    disabled: true,
                    label    : "履歴がありません"
                }));*/
                event.preventDefault();
            }
        },

        createFaviconMenuitem(doc, label, icon, value, command) {
            const attr = {
                class:    "menuitem-iconic bookmark-item menuitem-with-favicon",
                label:    label,
                value:    value
            };
            if (icon) {
                if (/^https?:/.test(icon))
                    icon = "moz-anno:favicon:" + icon;
                attr.image = icon;
            }
            const m = this.$C(doc, "menuitem", attr);
            m.addEventListener("command", command, false);
            return m;
        },

        undoTab(event) {
            undoCloseTab(event.originalTarget.getAttribute("value"));
        },
        undoWindow(event) {
            undoCloseWindow(event.originalTarget.getAttribute("value"));
        },
        removeChilds(element) {
            const range = document.createRange();
            range.selectNodeContents(element);
            range.deleteContents();
        },

        onClick(event) {
            if (event.button === 1) {
                switch (event.originalTarget.localName) {
                case "box":    // -Fx65
                case "scrollbox":    // Fx66-
                case "toolbarbutton":
                    event.preventDefault();
                    event.stopPropagation();
                    undoCloseTab();
                    break;
                }
            }
        },

        $C(doc, tag, attrs) {
            const e = tag instanceof Node? tag: doc.createElementNS(XULNS, tag);
            if (attrs) {
                Object.entries(attrs).forEach(([key, value]) => e.setAttribute(key, value));
            }
            return e;
        },
    };

    function run() {
        if (useTabbarMiddleClick) {
            gBrowser.tabContainer.addEventListener("click", ucjsUndoCloseTabButtonService.onClick, true);
        }

        const buttonId = "undo1-close-tab-button";

        if (document.getElementById(buttonId)) {
            return;
        }

        try {
            Cu.import("resource:///modules/CustomizableUI.jsm");
            CustomizableUI.createWidget({
                id            : buttonId,
                defaultArea    : CustomizableUI.AREA_NAVBAR,
                type        : "custom",
                onBuild        : doc => {
                    const btn = ucjsUndoCloseTabButtonService.$C(doc, "toolbarbutton", {
                        id                : buttonId,
                        class            : "toolbarbutton-1 chromeclass-toolbar-additional",
                        type            : "menu",
                        anchor            : "dropmarker",
                    label:            "Geschlossene Tabs",
                    tooltiptext:    "Geschlossene Tabs wieder herstellen",
                        image            : "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAAsTAAALEwEAmpwYAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAADgUlEQVR42mL8//8/AyUAIIBYYIzVq1dLC4mIrvr08ZPV379/vjEzMwOZnycmxMV04DMAIIAYQC4A4dXr1oU+fvLk/5/fv/9//fzl/9ev3/6vWLnqK0weFwYIIBZ0A79//crw5+9fhh+//jBYWlhz1dc3fgIqZeDh4WHk4uaqysnKmoysHiCAwAbceHRD6uLdQ0kGunoMv9hYGX79/sPw7cdvhn///jNYWJjzgtRw8/AwvHz5smzutlbN4yeP/k8Pqeo11bW5BxBAjCBnFPbHd7EIMJRoiZgx8nBwMvz+85fhJ9CQf3//Mzx9+pQBFM483FwMQG8xMDL/ZXj46cZ/9v/sk6ZWriwACCCwC25eviprEKbGeOP/AYavb34wsHCwMPz9AzTg9z+GP7x/Gf7++ws07B/Djz+/GZiYGBhYBdgYrx68JwXUyggQQGADePgFfjD+ZGHgF+Bl+P7yHZDPycDGws2gKW7GIMAhwnDs4XaGJ1/uMPz+8Z2BnYOZ4fOnzwwsrMxfgVr/AwQQ2ABpGYkv/GLcDELSfEDn/2HgFeZh8JdLYfjw6SODvqw5g4KiPMOsMw0MDEDbOYWABrz5zsAtI/wJpBcggJhABD+P8MefX38x/AU6k+EvIwPHHx4GNgYuhuuPLzCcuL2f4QswZozEHBjYGDmAdjIw/Pn+l0FCVOoNSC9AAIENEBEQe/Pjy0+GP8CA42LgZ/BXTWb48OUdw6m7+xmm7W5hePTqLoOLaigD+28+hnfv3jN8ePMJaIDMc5BegAACGyApLPX82+fvDB/ev2f4/eU/Ax+bEMOLd08ZpITkGbTl9IHp4jfDsev7GL59/8Lw+9dvhp/ffjPISio+BekFCCCwAQpiyrdfPn3F8OrVa4bHr+8zXHxwioGbjY+hwq+PwVkzmCHYMpFBS84A6Pp/DP/+/2P4+/Mvg5Ks+gOQXoAAggSimNqTb59+/v7x7SfL289vGRccmMDAxyrEsO3sKmCC+sKw9+xmhicf7gLxfQZ2QSaG/38YfkvyyoPCgBEggMAGfPnyhV2eV6vzxs7LWr9//Gf+yPKS6f/fl8zAhMgISkX//11h+M/I+A/ohL/f2P7/1VA2uvb161cOkAMAAogRmp1Znz17xsrCwsL07ds3lu/fvzOD2D9+/GCCpXk2Nra/XFxc/4Bif7i5uf9ISUn9Bgr/BggwAMhljD12v/akAAAAAElFTkSuQmCC",
                        onclick            : "ucjsUndoCloseTabButtonService.onClick(event);",
                        oncontextmenu    : "event.preventDefault();",
                    });
                    const menu = ucjsUndoCloseTabButtonService.$C(doc, "menupopup", {
                        tooltip                : "bhTooltip",
                        popupsinherittooltip: "true",
                        oncontextmenu        : "event.preventDefault();",
                        onpopupshowing        : "ucjsUndoCloseTabButtonService.prepareMenu(event);",
                    });
                    btn.appendChild(menu);
                    return btn;
                },
            });
        } catch (e) {}
    }

    if (gBrowserInit.delayedStartupFinished) {
        run();
    } else {
        const OBS_TOPIC = "browser-delayed-startup-finished";
        const delayedStartupFinished = (subject, topic) => {
            if (topic === OBS_TOPIC && subject === window) {
                Services.obs.removeObserver(delayedStartupFinished, topic);
                run();
            }
        };
        Services.obs.addObserver(delayedStartupFinished, OBS_TOPIC);
    }
})();