Firefox 149 beta: issues with the StyloaiX and Script Manager menupopup (rebuild)

[srjjgm]

In the StyloaiX toolbar button menu popup, disabled styles appear "checked," as if they were enabled.

In the Firefox main menu popup, middle-clicking does not change the enabled/disabled script icon. However, in the script manager menu popup on the toolbar, the icon changes correctly.
Also, since Firefox 148, the StyloaiX script is not disabled immediately when clicked in either menu; the browser needs to be restarted for it to take effect. Previously, the effect was immediate.

Can anyone help with this, please?

[117649]

Fix check mark for me.

utils\userChrome.jsm

const { xPref } = ChromeUtils.importESModule('chrome://userchromejs/content/xPref.mjs');
const { Management } = ChromeUtils.importESModule('resource://gre/modules/Extension.sys.mjs');
const { AppConstants } = ChromeUtils.importESModule('resource://gre/modules/AppConstants.sys.mjs');

let UC = {
  webExts: new Map(),
  sidebar: new Map(),
  sandboxes: new WeakMap()
};

let _uc = {
  ALWAYSEXECUTE: 'rebuild_userChrome.uc.js',
  BROWSERCHROME: AppConstants.MOZ_APP_NAME == 'thunderbird' ? 'chrome://messenger/content/messenger.xhtml' : 'chrome://browser/content/browser.xhtml',
  BROWSERTYPE: AppConstants.MOZ_APP_NAME == 'thunderbird' ? 'mail:3pane' : 'navigator:browser',
  BROWSERNAME: AppConstants.MOZ_APP_NAME.charAt(0).toUpperCase() + AppConstants.MOZ_APP_NAME.slice(1),
  PREF_ENABLED: 'userChromeJS.enabled',
  PREF_SCRIPTSDISABLED: 'userChromeJS.scriptsDisabled',

  chromedir: Services.dirsvc.get('UChrm', Ci.nsIFile),
  scriptsDir: '',

  sss: Cc["@mozilla.org/content/style-sheet-service;1"].getService(Ci.nsIStyleSheetService),

  getScripts: function () {
    this.scripts = {};
    let files = this.chromedir.directoryEntries.QueryInterface(Ci.nsISimpleEnumerator);
    while (files.hasMoreElements()) {
      let file = files.getNext().QueryInterface(Ci.nsIFile);
      if (/\.uc\.js$/i.test(file.leafName)) {
        _uc.getScriptData(file);
      }
    }
  },

  getScriptData: function (aFile) {
    let aContent = this.readFile(aFile);
    let header = (aContent.match(/^\/\/ ==UserScript==\s*\n(?:.*\n)*?\/\/ ==\/UserScript==\s*\n/m) || [''])[0];
    let match, rex = {
      include: [],
      exclude: []
    };
    let findNextRe = /^\/\/ @(include|exclude)\s+(.+)\s*$/gm;
    while ((match = findNextRe.exec(header))) {
      rex[match[1]].push(match[2].replace(/^main$/i, _uc.BROWSERCHROME).replace(/\*/g, '.*?'));
    }
    if (!rex.include.length) {
      rex.include.push(_uc.BROWSERCHROME);
    }
    let exclude = rex.exclude.length ? '(?!' + rex.exclude.join('$|') + '$)' : '';

    let def = ['', ''];
    let author = (header.match(/\/\/ @author\s+(.+)\s*$/im) || def)[1];
    let filename = aFile.leafName || '';

    return this.scripts[filename] = {
      filename: filename,
      file: aFile,
      url: Services.io.getProtocolHandler('file').QueryInterface(Ci.nsIFileProtocolHandler).getURLSpecFromDir(this.chromedir) + filename,
      name: (header.match(/\/\/ @name\s+(.+)\s*$/im) || def)[1],
      description: (header.match(/\/\/ @description\s+(.+)\s*$/im) || def)[1],
      version: (header.match(/\/\/ @version\s+(.+)\s*$/im) || def)[1],
      author: (header.match(/\/\/ @author\s+(.+)\s*$/im) || def)[1],
      regex: new RegExp('^' + exclude + '(' + (rex.include.join('|') || '.*') + ')$', 'i'),
      id: (header.match(/\/\/ @id\s+(.+)\s*$/im) || ['', filename.split('.uc.js')[0] + '@' + (author || 'userChromeJS')])[1],
      homepageURL: (header.match(/\/\/ @homepageURL\s+(.+)\s*$/im) || def)[1],
      downloadURL: (header.match(/\/\/ @downloadURL\s+(.+)\s*$/im) || def)[1],
      updateURL: (header.match(/\/\/ @updateURL\s+(.+)\s*$/im) || def)[1],
      optionsURL: (header.match(/\/\/ @optionsURL\s+(.+)\s*$/im) || def)[1],
      startup: (header.match(/\/\/ @startup\s+(.+)\s*$/im) || def)[1],
      shutdown: (header.match(/\/\/ @shutdown\s+(.+)\s*$/im) || def)[1],
      onlyonce: /\/\/ @onlyonce\b/.test(header),
      isRunning: false,
      get isEnabled() {
        return (xPref.get(_uc.PREF_SCRIPTSDISABLED) || '').split(',').indexOf(this.filename) == -1;
      }
    }
  },

  readFile: function (aFile, metaOnly = false) {
    let stream = Cc['@mozilla.org/network/file-input-stream;1'].createInstance(Ci.nsIFileInputStream);
    stream.init(aFile, 0x01, 0, 0);
    let cvstream = Cc['@mozilla.org/intl/converter-input-stream;1'].createInstance(Ci.nsIConverterInputStream);
    cvstream.init(stream, 'UTF-8', 1024, Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
    let content = '',
        data = {};
    while (cvstream.readString(4096, data)) {
      content += data.value;
      if (metaOnly && content.indexOf('// ==/UserScript==') > 0) {
        break;
      }
    }
    cvstream.close();
    return content.replace(/\r\n?/g, '\n');
  },

  everLoaded: [],
  
  loadScript: function (script, win) {
    if (!script.regex.test(win.location.href) || (script.filename != this.ALWAYSEXECUTE && !script.isEnabled)) {
      return;
    }

    if (script.onlyonce && script.isRunning) {
      if (script.startup) {
        Cu.evalInSandbox(`(function(script, win){${script.startup}})`, this.getSandbox(win), null, `startup-->${script.filename}`, 1)(script, win);
      }
      return;
    }

    try {
      Services.scriptloader.loadSubScript(script.url + '?' + script.file.lastModifiedTime,
                                          script.onlyonce ? { window: win } : win);
      script.isRunning = true;
      if (script.startup) {
        Cu.evalInSandbox(`(function(script, win){${script.startup}})`, this.getSandbox(win), null, `startup-->${script.filename}`, 1)(script, win);
      }
      if (!script.shutdown) {
        this.everLoaded.push(script.id);
      }
    } catch (ex) {
      Cu.reportError(ex);
    }
  },

  getSandbox: function (doc) {
    if (!UC.sandboxes) UC.sandboxes = new WeakMap();
    let global = Cu.getGlobalForObject(doc);
    if (UC.sandboxes.has(global)) 
      return UC.sandboxes.get(global);
    let sb = Cu.Sandbox(Services.scriptSecurityManager.getSystemPrincipal(), {
      sandboxPrototype: global,
      sameZoneAs: global,
      wantXrays: false,
      sandboxName: 'UCJS:Sandbox'
    });
    UC.sandboxes.set(global, sb);
    global.addEventListener('unload', () => {
      UC.sandboxes.delete(global);
      Cu.nukeSandbox(sb);
    });
    return sb;
  },

  windows: function (fun, onlyBrowsers = true) {
    let windows = Services.wm.getEnumerator(onlyBrowsers ? this.BROWSERTYPE : null);
    while (windows.hasMoreElements()) {
      let win = windows.getNext();
      if (!win._uc)
        continue;
      if (!onlyBrowsers) {
        let frames = win.docShell.getAllDocShellsInSubtree(Ci.nsIDocShellTreeItem.typeAll, Ci.nsIDocShell.ENUMERATE_FORWARDS);
        let res = frames.some(frame => {
          let fWin = frame.domWindow;
          let {document, location} = fWin;
          if (fun(document, fWin, location))
            return true;
        });
        if (res)
          break;
      } else {
        let {document, location} = win;
        if (fun(document, win, location))
          break;
      }
    }
  },

  createElement: function (doc, tag, atts, XUL = true) {
    let el = XUL ? doc.createXULElement(tag) : doc.createElement(tag);
    for (let att in atts) {
      if (att.startsWith('on'))
        el.addEventListener(att.slice(2), typeof atts[att] == "string" ?
          Cu.evalInSandbox(`(function(event){${atts[att]}})`, this.getSandbox(doc), null, el.baseURI + `?${tag}#${atts.id}[${atts.label}]${att}`, 1) : atts[att]);
      else
        if (att == 'checked') atts[att] ? el.setAttribute(att, 'true') : void 0;
        else el.setAttribute(att, atts[att]);
    }
    return el
  }
};

if (xPref.get(_uc.PREF_ENABLED) === undefined) {
  xPref.set(_uc.PREF_ENABLED, true, true);
}

if (xPref.get(_uc.PREF_SCRIPTSDISABLED) === undefined) {
  xPref.set(_uc.PREF_SCRIPTSDISABLED, '', true);
}

let UserChrome_js = {
  observe: function (aSubject) {
    aSubject.addEventListener('DOMContentLoaded', this, {once: true});
  },

  handleEvent: function (aEvent) {
    let document = aEvent.originalTarget;
    let window = document.defaultView;
    if (window.document.isInitialDocument) this.load(window.parent);
    else this.load(window);
  },

  load: function (window) {
    let location = window.location;

    if (!this.sharedWindowOpened && location.href == 'chrome://extensions/content/dummy.xhtml') {
      this.sharedWindowOpened = true;

      Management.on('extension-browser-inserted', function (topic, browser) {
        browser.messageManager.addMessageListener('Extension:BackgroundViewLoaded', this.messageListener.bind(this));
      }.bind(this));
    } else if (/^(chrome:(?!\/\/global\/content\/commonDialog\.x?html)|about:(?!blank))/i.test(location.href)) {
      window.UC = UC;
      window._uc = _uc;
      window.xPref = xPref;
      if (window._gBrowser) // bug 1443849
        window.gBrowser = window._gBrowser;

      if (xPref.get(_uc.PREF_ENABLED)) {
        Object.values(_uc.scripts).forEach(script => {
          _uc.loadScript(script, window);
        });
      } else if (!UC.rebuild) {
        _uc.loadScript(_uc.scripts[_uc.ALWAYSEXECUTE], window);
      }
    }
  },

  messageListener: function (msg) {
    const browser = msg.target;
    const { addonId } = browser._contentPrincipal;

    browser.messageManager.removeMessageListener('Extension:BackgroundViewLoaded', this.messageListener);

    if (browser.ownerGlobal.location.href == 'chrome://extensions/content/dummy.xhtml') {
      UC.webExts.set(addonId, browser);
      Services.obs.notifyObservers(null, 'UCJS:WebExtLoaded', addonId);
    } else {
      let win = browser.ownerGlobal.windowRoot.ownerGlobal;
      UC.sidebar.get(addonId)?.set(win, browser) || UC.sidebar.set(addonId, new Map([[win, browser]]));
      Services.obs.notifyObservers(win, 'UCJS:SidebarLoaded', addonId);
    }
  }
};

if (!Services.appinfo.inSafeMode) {
  _uc.chromedir.append(_uc.scriptsDir);
  _uc.getScripts();
  let windows = Services.wm.getEnumerator(null);
  while (windows.hasMoreElements()) {
    let win = windows.getNext();
    if (!('UC' in win))
      UserChrome_js.load(win)
  }
  Services.obs.addObserver(UserChrome_js, 'chrome-document-global-created', false);
}

styloaix.uc.js

// ==UserScript==
// @name            StyloaiX
// @author          xiaoxiaoflood
// @include         *
// @startup         UC.styloaix.exec(win);
// @shutdown        UC.styloaix.destroy();
// @onlyonce
// ==/UserScript==

// inspired by legacy Stylish and https://github.com/Endor8/userChrome.js/blob/master/Updates%202019/UserCSSLoader.uc.js
// editor forked from Stylish - minor changes to edit.xhtml, but edit.js almost completely rewritten, with improvements and bug fixes.
// icon from old Stylish

// search for "userChromeJS.styloaix" in about:config to change settings.

// exclusive prefs for Thunderbird:
// - userChromeJS.styloaix.buttonRefElement:
//     CSS selector for the element StyloaiX button depends on for its insertion in main window.
//     default is the ☰ button.
// - userChromeJS.styloaix.buttonPosition:
//     related to previous pref. Should be a number between 0 and 3:
//     - 0: button will be inserted BEFORE ref element (default);
//     - 1: button will be the FIRST CHILD of ref relement;
//     - 2: button will be the LAST CHILD of ref relement;
//     - 3: button will be inserted AFTER ref relement.

(function () {
  UC.styloaix = {
    exec: function (win) {
      if (win.location.href !== _uc.BROWSERCHROME && win.location.href !== this.TBDETACHEDMAIL && win.location.href !== this.TBMAILCOMPOSEWIN)
        return;

      const { CustomizableUI, document } = win;
      if (AppConstants.MOZ_APP_NAME !== 'thunderbird') {
        if (!CustomizableUI.getPlacementOfWidget('styloaix-button')) {
          CustomizableUI.createWidget({
            id: 'styloaix-button',
            type: 'custom',
            defaultArea: CustomizableUI.AREA_NAVBAR,
            onBuild: (doc) => {
              return this.createButton(doc);
            }
          });
        }
      } else {
        const btn = this.createButton(document);

        if (win.location.href === _uc.BROWSERCHROME) {
          btn.removeAttribute('label');
          btn.classList.add('button', 'toolbar-button');

          let observer = (subject) => {
            this.insertTbButton(btn);
            Services.obs.removeObserver(observer, 'browser-delayed-startup-finished');
          }

          if (document.readyState !== 'complete')
            Services.obs.addObserver(observer, 'browser-delayed-startup-finished');
          else
            this.insertTbButton(btn);
        } else {
          btn.setAttribute('removable', true);
          const toolbar = document.querySelector('toolbar[customizable=true].chromeclass-toolbar');
          if (toolbar.parentElement.palette)
            toolbar.parentElement.palette.appendChild(btn);
          else
            toolbar.appendChild(btn);

          if (xPref.get(this.PREF_FIRSTRUN)) {
            xPref.set(this.PREF_FIRSTRUN, false);
            if (!toolbar.getAttribute('currentset').split(',').includes(btn.id)) {
              toolbar.appendChild(btn);
              toolbar.setAttribute('currentset', toolbar.currentSet);
              Services.xulStore.persist(toolbar, 'currentset');
            }
          } else {
            toolbar.currentSet = Services.xulStore.getValue(win.location.href, toolbar.id, 'currentset');
            toolbar.setAttribute('currentset', toolbar.currentSet);
          }
        }

        this.tbButtons.push(btn);
      }
    },

    init: function () {
      xPref.set(this.PREF_FIRSTRUN, true, true);
      xPref.set(this.PREF_DISABLED, false, true);
      xPref.set(this.PREF_STYLESDISABLED, '[]', true);
      xPref.set(this.PREF_INSTANTCHECK, true, true);
      xPref.set(this.PREF_INSTANTPREVIEW, true, true);
      xPref.set(this.PREF_INSTANTINTERVAL, 500, true);
      xPref.set(this.PREF_LINEWRAPPING, true, true);
      xPref.set(this.PREF_OPENINWINDOW, true, true);
      xPref.set(this.PREF_TBBTNREFELEMENT, '#button-appmenu', true);
      xPref.set(this.PREF_TBBTNREFPOSITION, 0, true);

      this.prefListenerDisabledStyles = xPref.addListener(this.PREF_STYLESDISABLED, (sDisabled) => {
        let newSet;
        try {
          newSet = new Set(JSON.parse(sDisabled));
        } catch {
          xPref.set(this.PREF_STYLESDISABLED, JSON.stringify([...this.disabledStyles]));
          return;
        }

        this.styles.forEach(style => {
          if ((style.enabled && newSet.has(style.fullName)) ||
              (!style.enabled && !newSet.has(style.fullName)))
            this.toggleStyle(style);
        });
      });

      this.prefListenerStateEnabled = xPref.addListener(this.PREF_DISABLED, (disabled) => {
        this.toggleAll({disable: disabled});
        this.btnClasses.reverse();
        _uc.windows((doc) => {
          let enabledBtn = doc.getElementById('styloaix-enabled');
          enabledBtn.label = disabled ? 'Disabled' : 'Enabled';
          disabled ? enabledBtn.removeAttribute('checked') : enabledBtn.setAttribute('checked', 'true');
          doc.getElementById('styloaix-button').classList.replace(...this.btnClasses);
          doc.getElementById('styloaix-reload-all').disabled = disabled;
        });
      });

      this.prefListenerTbBtnRef = xPref.addListener(this.PREF_TBBTNREFELEMENT, () => {
        this.insertTbButton();
      });

      this.prefListenerTbBtnRefPos = xPref.addListener(this.PREF_TBBTNREFPOSITION, () => {
        this.insertTbButton();
      });

      this.disabledStyles = new DisabledSet(JSON.parse(xPref.get(this.PREF_STYLESDISABLED)).sort((a, b) => a[0].localeCompare(b[0])));

      this.UserStyle = UserStyle;

      if (!this.enabled)
        this.btnClasses.reverse();

      this.loadStyles();

      _uc.sss.loadAndRegisterSheet(this.STYLE.url, this.STYLE.type);
    },

    get tbBtnRefPosition() {
      switch (xPref.get(this.PREF_TBBTNREFPOSITION)) {
        default:
          return 'beforebegin';
        case 1:
          return 'afterbegin';
        case 2:
          return 'beforeend';
        case 3:
          return 'afterend';
      }
    },

    insertTbButton (btn) {
      let win = Services.wm.getMostRecentBrowserWindow('navigator');
      btn ??= win.document.getElementById('styloaix-button');
      let refElement = win.document.querySelector(xPref.get(this.PREF_TBBTNREFELEMENT));
      refElement?.insertAdjacentElement(this.tbBtnRefPosition, btn);
    },

    createButton (doc) {
      let btn = _uc.createElement(doc, 'toolbarbutton', {
        id: 'styloaix-button',
        label: 'StyloaiX',
        tooltiptext: 'StyloaiX',
        type: 'menu',
        class: 'toolbarbutton-1 chromeclass-toolbar-additional ' + this.btnClasses[1],
        onclick: 'if (event.button === 1 && event.target.id == this.id) UC.styloaix.enabled = !UC.styloaix.enabled;'
      });

      let popup = _uc.createElement(doc, 'menupopup', {id: 'styloaix-popup'});
      btn.appendChild(popup);
      btn.addEventListener('popupshowing', this.populateMenu);

      let disabled = xPref.get(this.PREF_DISABLED);
      let toggleBtn = _uc.createElement(doc, 'menuitem', {
        id: 'styloaix-enabled',
        label: disabled ? 'Disabled' : 'Enabled',
        type: 'checkbox',
        checked: !disabled,
        oncommand: 'UC.styloaix.enabled = !UC.styloaix.enabled;'
      });
      popup.appendChild(toggleBtn);

      let menuseparator = _uc.createElement(doc, 'menuseparator');
      popup.appendChild(menuseparator);

      let reloadAllBtn = _uc.createElement(doc, 'menuitem', {
        id: 'styloaix-reload-all',
        label: 'Reload All Styles',
        disabled: !this.enabled,
        oncommand: 'UC.styloaix.toggleAll({reload: true});'
      });
      popup.appendChild(reloadAllBtn);

      let openFolderBtn = _uc.createElement(doc, 'menuitem', {
        id: 'styloaix-open-folder',
        label: 'Open folder',
        oncommand: 'UC.styloaix.CSSDIR.launch();'
      });
      popup.appendChild(openFolderBtn);

      let newStyleMenu = _uc.createElement(doc, 'menu', {
        id: 'styloaix-new-style',
        label: 'New Style'
      });

      let newStylePopup = _uc.createElement(doc, 'menupopup', {id: 'styloaix-newstyle-popup'});

      let newPageStyleBtn = _uc.createElement(doc, 'menuitem', {
        label: 'For this page',
        oncommand: 'UC.styloaix.openEditor({url: gBrowser.currentURI.specIgnoringRef, type: "url"});'
      });
      newStylePopup.appendChild(newPageStyleBtn);

      let newSiteStyleBtn = _uc.createElement(doc, 'menuitem', {
        label: 'For this site',
        oncommand: 'let host = gBrowser.currentURI.asciiHost; UC.styloaix.openEditor({url: host || gBrowser.currentURI.specIgnoringRef, type: host ? "domain" : "url"});'
      });
      newStylePopup.appendChild(newSiteStyleBtn);

      let newStyle = _uc.createElement(doc, 'menuitem', {
        label: 'Blank Style',
        oncommand: 'UC.styloaix.openEditor();'
      });
      newStylePopup.appendChild(newStyle);

      newStyleMenu.appendChild(newStylePopup);
      popup.appendChild(newStyleMenu);

      let separatorBeforeStyles = _uc.createElement(doc, 'menuseparator', {id: 'styloaix-separator'});
      separatorBeforeStyles.hidden = !this.styles.size;
      popup.appendChild(separatorBeforeStyles);
      btn._separator = separatorBeforeStyles;

      let stylePopup = _uc.createElement(doc, 'menupopup', {id: 'styloaix-style-context'});

      let styleEdit = _uc.createElement(doc, 'menuitem', {
        id: 'styloaix-style-edit',
        label: 'Edit',
        oncommand: 'UC.styloaix.openEditor({id: this.parentNode.triggerNode._style.fullName})'
      });
      stylePopup.appendChild(styleEdit);

      let styleReload = _uc.createElement(doc, 'menuitem', {
        id: 'styloaix-style-reload',
        label: 'Reload',
        oncommand: 'this.parentNode.triggerNode._style.reload()'
      });
      stylePopup.appendChild(styleReload);

      let styleDelete = _uc.createElement(doc, 'menuitem', {
        id: 'styloaix-style-delete',
        label: 'Delete',
        oncommand: 'this.parentNode.triggerNode._style.delete()'
      });
      stylePopup.appendChild(styleDelete);

      doc.getElementById('mainPopupSet').appendChild(stylePopup);

      return btn;
    },

    get enabled () {
      return !xPref.get(this.PREF_DISABLED);
    },

    set enabled (val) {
      xPref.set(this.PREF_DISABLED, !val);
    },

    loadStyles: function() {
      let files = this.CSSDIR.directoryEntries.QueryInterface(Ci.nsISimpleEnumerator);
      while (files.hasMoreElements()) {
        let file = files.getNext().QueryInterface(Ci.nsIFile);
        if (file.leafName.endsWith('.css')) {
          let style = new UserStyle(file);
        }
      }

      if (this.enabled)
        this.toggleAll({disable: false});
    },

    toggleAll: function ({disable = this.enabled, reload = false} = {}) {
      this.styles.forEach(style => {
        if (style.enabled)
          this.toggleStyle(style, {aStatus: !disable, changeStatus: false, forced: true});
      });
      if (reload) {
        this.styles = new Map();
        this.loadStyles();
      }
    },

    toggleStyle: function (style, {aStatus = !style.enabled, changeStatus = true, forced = false} = {}) {
      if (this.enabled || forced) {
        if (aStatus)
          style.register();
        else
          style.unregister();
      }
      if (changeStatus) {
        this.changeStatus(style, aStatus);
      }
      if (style.type === _uc.sss.AGENT_SHEET && !this.hasListener)
        this.forceRefresh();
    },

    forceRefresh: function () {
      let win = Services.wm.getMostRecentWindow(null);
      let cacheVal = win.browsingContext.prefersColorSchemeOverride;
      let oppositeColorScheme = Services.appinfo.chromeColorSchemeIsDark ? 'light' : 'dark';
      let mql = win.matchMedia('(prefers-color-scheme: ' + oppositeColorScheme + ')');
      let lis = function () {
        this.hasListener = false
        mql.removeListener(lis);
        win.browsingContext.prefersColorSchemeOverride = cacheVal;
      };
      this.hasListener = true;
      mql.addListener(lis);
      win.browsingContext.prefersColorSchemeOverride = oppositeColorScheme;
    },

    changeStatus: function (style, aStatus) {
      style.enabled = aStatus;
      _uc.windows((doc) => {
        let menuitem = doc.getElementById('styloaix-popup').getElementsByAttribute('styleid', style.fullName)[0];
        !aStatus ? menuitem?.removeAttribute('checked') : menuitem?.setAttribute('checked', 'true');
      });
      if (aStatus) {
        this.disabledStyles.delete(style.fullName);
      } else {
        this.disabledStyles.add(style.fullName);
      }
    },

    addStyleInMenu (style, popup) {
      let menuitem = _uc.createElement(popup.ownerDocument, 'menuitem', {
        label: style.name,
        type: 'checkbox',
        class: 'styloaix-style' + (style.type == _uc.sss.AUTHOR_SHEET ?
                                     '' :
                                     ' styloaix-' + (style.type == _uc.sss.USER_SHEET ?
                                       'user' :
                                       'agent') + 'sheet'),
        acceltext: style.type == _uc.sss.AGENT_SHEET? 'AG' : style.type == _uc.sss.USER_SHEET  ? 'US' : '',
        checked: style.enabled,
        context: 'styloaix-style-context',
        oncommand: 'UC.styloaix.toggleStyle(this._style);',
        onmouseup: 'UC.styloaix.shouldPreventHide(event, this._style);',
        styleid: style.fullName
      });
      popup.appendChild(menuitem);
      menuitem._style = style;
    },

    shouldPreventHide: function (event, style) {
      const menuitem = event.target;
      if (event.button == 1 && !event.ctrlKey) {
        menuitem.setAttribute('closemenu', 'none');
        menuitem.parentNode.addEventListener('popuphidden', () => {
          menuitem.removeAttribute('closemenu');
        }, { once: true });
      } else {
        menuitem.removeAttribute('closemenu');
      }
    },

    populateMenu (e) {
      const popup = e.target;

      if (popup.id !== 'styloaix-popup')
        return;

      const doc = e.view.document;

      const stylesSeparator = popup.querySelector('#styloaix-separator');
      while (stylesSeparator.nextSibling)
        stylesSeparator.nextSibling.remove();

      const sortedMap = new Map([...UC.styloaix.styles.entries()].sort((a, b) => a[0].localeCompare(b[0])));
      sortedMap.forEach(style => {
        UC.styloaix.addStyleInMenu(style, popup);
      });
    },

    openEditor ({id, url, type} = {}) {
      if (xPref.get(this.PREF_OPENINWINDOW)) {
        Services.wm.getMostRecentWindow(null).openDialog(this.EDITOR_URI, (id || Math.random()) + ' - StyloaiX Editor', 'centerscreen,chrome,resizable,dialog=no', {id, url, type});
      } else {
        let appendUrl = '';
        if (id != undefined)
          appendUrl = '?id=' + id;
        else if (url)
          appendUrl = '?url=' + encodeURIComponent(url) + '&type=' + type;
        Services.wm.getMostRecentBrowserWindow().switchToTabHavingURI(this.EDITOR_URI + appendUrl, true);
      }
    },

    get CSSDIR () {
      let cssFolder = _uc.chromedir.clone();
      cssFolder.append('UserStyles');
      if (!cssFolder.exists() || !cssFolder.isDirectory())
        cssFolder.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755/*FileUtils.PERMS_DIRECTORY*/);
      Object.defineProperty(this, 'CSSDIR', { value: cssFolder });
      return cssFolder;
    },

    btnClasses: ['icon-white', 'icon-colored'],

    PREF_FIRSTRUN: 'userChromeJS.styloaix.firstRun',
    PREF_DISABLED: 'userChromeJS.styloaix.allDisabled',
    PREF_STYLESDISABLED: 'userChromeJS.styloaix.stylesDisabled',
    PREF_INSTANTCHECK: 'userChromeJS.styloaix.instantCheck',
    PREF_INSTANTPREVIEW: 'userChromeJS.styloaix.instantPreview',
    PREF_INSTANTINTERVAL: 'userChromeJS.styloaix.instantInterval',
    PREF_OPENINWINDOW: 'userChromeJS.styloaix.openInWindow',
    PREF_LINEWRAPPING: 'userChromeJS.styloaix.lineWrapping',
    PREF_TBBTNREFELEMENT: 'userChromeJS.styloaix.buttonRefElement',
    PREF_TBBTNREFPOSITION: 'userChromeJS.styloaix.buttonPosition',
    EDITOR_URI: 'chrome://userchromejs/content/styloaix/edit.xhtml',
    STYLESDIR: 'resource://userchromejs/' + (_uc.scriptsDir ? _uc.scriptsDir + '/' : '') + 'UserStyles/',
    TBDETACHEDMAIL: 'chrome://messenger/content/messageWindow.xhtml',
    TBMAILCOMPOSEWIN: 'chrome://messenger/content/messengercompose/messengercompose.xhtml',

    STYLE: {
      get url() {
        return this.url = Services.io.newURI('data:text/css;charset=UTF-8,' + encodeURIComponent(`
          @-moz-document url('${_uc.BROWSERCHROME}'), url('chrome://messenger/content/customizeToolbar.xhtml'), url('${UC.styloaix.TBDETACHEDMAIL}'), url('${UC.styloaix.TBMAILCOMPOSEWIN}') {
            #styloaix-button.icon-white {
              list-style-image: url('chrome://userchromejs/content/styloaix/16w.png');
            }
            #styloaix-button.icon-colored {
              list-style-image: url('chrome://userchromejs/content/styloaix/16.png');
            }
            .styloaix-usersheet .menu-iconic-accel,
            .styloaix-usersheet .menu-accel {
              color: blue !important;
            }
            .styloaix-agentsheet .menu-iconic-accel,
            .styloaix-agentsheet .menu-accel {
              color: green !important;
            }
            #styloaix-button > label {
              display: none;
            }
          }
          /* bug 1719535 caused "!important" to be able to wrap in different lines,
           * as if "!" were a word. It's not, "!important" must not be separated.
           */
          @-moz-document url-prefix('chrome://devtools/content/shared/sourceeditor/codemirror/cmiframe.html') {
            .CodeMirror pre.CodeMirror-line > span > span:is(.cm-keyword, .cm-variable-2, .cm-number) {
              white-space: nowrap;
            }
          }
        `));
      },
      type: _uc.sss.USER_SHEET
    },

    styles: new Map(),

    tbButtons: [],

    destroy: function () {
      xPref.removeListener(this.prefListenerDisabledStyles);
      xPref.removeListener(this.prefListenerStateEnabled);
      xPref.removeListener(this.prefListenerTbBtnRef);
      xPref.removeListener(this.prefListenerTbBtnRefPos);

      if (Services.wm.getMostRecentWindow(null).AppConstants.MOZ_APP_NAME !== 'thunderbird')
        Services.wm.getMostRecentBrowserWindow().CustomizableUI.destroyWidget('styloaix-button');
      else
        this.tbButtons.forEach(b => b.remove());

      _uc.sss.unregisterSheet(this.STYLE.url, this.STYLE.type);

      this.toggleAll({disable: true});

      delete UC.styloaix;
    }
  }

  class DisabledSet extends Set {
    constructor (iterable) {
      super(iterable);
    }

    add (item) {
      let cache_add = Set.prototype.add.call(this, item);
      xPref.set(UC.styloaix.PREF_STYLESDISABLED, JSON.stringify([...this]));
      return cache_add;
    }

    delete (item) {
      let cache_delete = Set.prototype.delete.call(this, item);
      xPref.set(UC.styloaix.PREF_STYLESDISABLED, JSON.stringify([...this]));
      return cache_delete;
    }
  }

  class UserStyle {
    constructor(file) {
      this.type = file.leafName.endsWith('.us.css') ?
                    _uc.sss.USER_SHEET :
                  file.leafName.endsWith('.as.css') ?
                    _uc.sss.AGENT_SHEET :
                    _uc.sss.AUTHOR_SHEET;
      this.file = file;
      this.fullName = file.leafName;
      this.name = file.leafName.replace(/(?:\.(?:user|as|us))?\.css$/, '');
      this.url = Services.io.newURI(UC.styloaix.STYLESDIR + file.leafName);
      this.enabled = !UC.styloaix.disabledStyles.has(this.fullName);
      UC.styloaix.styles.set(this.fullName, this);
    }
    register () {
      _uc.sss.loadAndRegisterSheet(this.url, this.type);
    }
    unregister () {
      _uc.sss.unregisterSheet(this.url, this.type);
    }
    reload () {
      if (this.enabled)
        this.unregister();
      UC.styloaix.toggleStyle(this, {aStatus: true});
    }
    delete () {
      if (Services.prompt.confirm(null, 'StyloaiX', 'Delete "' + this.fullName + '" permanently?')) {
        UC.styloaix.styles.delete(this.fullName);
        if (this.enabled)
          this.unregister();
        else
          UC.styloaix.disabledStyles.delete(this.fullName);
        this.file.remove(false);
      }
    }
  }

  UC.styloaix.init();

})()

[srjjgm]

Thank you for your help, but it didn't work for me.
Perhaps you are not using the same files as me. The files I am using are the ones that were updated by @onemen on 01/30/2026.
Your userChrome.jsm file is very different from mine. Here the name is userChrome.js and the text has many differences, it looks like a different structure.
The styloaix.uc.js file is quite similar, but there are still differences. If it's important to mention, the rebuild_userChrome.uc.js file I'm using is from 01/20/2026.

[onemen]

read #386

Download utils

[srjjgm]

Download utils

I downloaded and compared it with the files I already use. They are all up to date.
Firefox 149 handles the checked attribute differently in the menuitem > .menu-icon element in the StyloaiX button's popup menu and also in the script manager's popup menu within the Firefox main menu.

And there's also another problem, which I don't know exactly in which version of Firefox it started: the toolbar's script manager button opens a popup menu when clicked, and note that the StyloaiX script is blue. The blue scripts, created by xiaoxiaoflood, are restartless, meaning they are enabled/disabled immediately, they don't require the browser to be restarted. This also applies to the Firefox main menu.

Of these problems, the most urgent and important is the checked attribute in the disabled menuitem, in the two menus mentioned.

[117649]

Download utils

I downloaded and compared it with the files I already use. They are all up to date.
Firefox 149 handles the checked attribute differently in the menuitem > .menu-icon element in the StyloaiX button's popup menu and also in the script manager's popup menu within the Firefox main menu.

And there's also another problem, which I don't know exactly in which version of Firefox it started: the toolbar's script manager button opens a popup menu when clicked, and note that the StyloaiX script is blue. The blue scripts, created by xiaoxiaoflood, are restartless, meaning they are enabled/disabled immediately, they don't require the browser to be restarted. This also applies to the Firefox main menu.

Of these problems, the most urgent and important is the checked attribute in the disabled menuitem, in the two menus mentioned.

What I see the problem is Mozilla simplified checked attribute from 'true' or 'false' value to has it or not. For compatibility reason you still want its has a value of 'true' if it appears.

You can search for the changes in my codes for adapt to above development and apply them to your own. Since you claim they're different in a significant way.

[117649]

And there's also another problem, which I don't know exactly in which version of Firefox it started: the toolbar's script manager button opens a popup menu when clicked, and note that the StyloaiX script is blue. The blue scripts, created by xiaoxiaoflood, are restartless, meaning they are enabled/disabled immediately, they don't require the browser to be restarted. This also applies to the Firefox main menu.

Make this change in a file which I don't remember its full name.

[srjjgm]

Make this change in a file which I don't remember its full name.

Thank you!
This works to make the text blue, but it doesn't disable/enable the script without restarting the browser. For some reason, this behavior has changed in more recent versions of Firefox.

[srjjgm]

You can search for the changes in my codes for adapt to above development and apply them to your own. Since you claim they're different in a significant way.

I tried adapting your text, but it didn't work. In fact, the files I use are very different, especially userChrome.js.

[117649]

but it doesn't disable/enable the script without restarting the browser. For some reason, this behavior has changed in more recent versions of Firefox.

That is within each script itself.

[srjjgm]

The scripts written by xiaoxiaoflood already have the startless condition in their code.
I think the problem with this no longer working might be in the rebuild_userChrome.uc.js file or in userChrome.js.

[117649]

The scripts written by xiaoxiaoflood already have the startless condition in their code.
I think the problem with this no longer working might be in the rebuild_userChrome.uc.js file or in userChrome.js.

No.
What they have is a 'shutdown' statement which is in plain text and have to be eval then excute.
Any link along that chain broke it won't work.

[srjjgm]

Ok, so we have to wait for the author to fix this.
Regarding the issue with the check mark in the disabled styles, I'll try to solve it with CSS, although it's not the ideal solution.
Thank you!

[srjjgm]

I fixed the visual part (check mark and blue restartless) with CSS. As I said, I don't know if it's ideal, but it's working.
The problem of needing to restart the browser to enable/disable scripts remains, but that seems much more difficult.
Here are the updated files, in case anyone wants to use them.

styloaix-rebuild.zip

[srjjgm]

Just one more observation here: I tested Thunderbird 149 beta and the "restartless" scripts are still working perfectly in it.
Scripts like StyloaiX and Master Password+, for example, can be effectively enabled/disabled in the TB main menu, without needing to restart it. Therefore, the problem I mentioned above only happens on Firefox.