magic-userjs.user.js

// ==UserScript==
// @version      7.6.8
// @name         Magic Userscript+ : Show Site All UserJS
// @name:ar      Magic Userscript+: عرض جميع ملفات UserJS
// @name:de      Magic Userscript+ : Website anzeigen Alle UserJS
// @name:es      Magic Userscript+: Mostrar sitio todos los UserJS
// @name:fr      Magic Userscript+ : Afficher le site Tous les UserJS
// @name:ja      Magic Userscript+ : サイトをすべて表示 UserJS
// @name:nl      Magic Userscript+: Site alle UserJS tonen
// @name:pl      Magic Userscript+ : Pokaż witrynę Wszystkie UserJS
// @name:ru      Magic Userscript+: показать сайт всем UserJS
// @name:zh      Magic Userscript+ ：显示站点所有 UserJS
// @name:zh-CN      Magic Userscript+ ：显示站点所有 UserJS
// @name:zh-TW      Magic Userscript+ ：显示站点所有 UserJS
// @description  Finds available userscripts for the current webpage.
// @description:ar      يبحث عن نصوص المستخدمين المتاحة لصفحة الويب الحالية.
// @description:de      Findet verfügbare Benutzerskripte für die aktuelle Webseite.
// @description:es      Busca los usercripts disponibles para la página web actual.
// @description:fr      Recherche les userscripts disponibles pour la page web en cours.
// @description:ja      現在のウェブページで利用可能なユーザスクリプトを検索します。
// @description:nl      Zoekt beschikbare gebruikerscripts voor de huidige webpagina.
// @description:pl      Wyszukuje dostępne skrypty użytkownika dla bieżącej strony internetowej.
// @description:ru      Находит доступные юзерскрипты для текущей веб-страницы.
// @description:zh      为当前网页查找可用的用户脚本。
// @description:zh-CN      为当前网页查找可用的用户脚本。
// @description:zh-TW      为当前网页查找可用的用户脚本。
// @author       Magic <magicoflolis@tuta.io>
// @supportURL   https://github.com/magicoflolis/Userscript-Plus/issues
// @namespace    https://github.com/magicoflolis/Userscript-Plus
// @homepageURL  https://github.com/magicoflolis/Userscript-Plus
// @icon         data:image/png;base64,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
// @downloadURL  https://github.com/magicoflolis/Userscript-Plus/raw/master/dist/magic-userjs.user.js
// @updateURL    https://github.com/magicoflolis/Userscript-Plus/raw/master/dist/magic-userjs.meta.js
// @license      MIT
// @compatible     chrome
// @compatible     firefox
// @compatible     edge
// @compatible     opera
// @compatible     safari
// @connect     greasyfork.org
// @connect     sleazyfork.org
// @connect     github.com
// @connect     githubusercontent.com
// @connect     openuserjs.org
// @grant     GM_addElement
// @grant     GM_info
// @grant     GM_getValue
// @grant     GM_openInTab
// @grant     GM_setValue
// @grant     GM_registerMenuCommand
// @grant     GM_xmlhttpRequest
// @grant     GM.addElement
// @grant     GM.info
// @grant     GM.getValue
// @grant     GM.openInTab
// @grant     GM.setValue
// @grant     GM.registerMenuCommand
// @grant     GM.xmlHttpRequest
// @match     https://*/*
// @noframes
// @run-at     document-start
// ==/UserScript==
(() => {
'use strict';
/******************************************************************************/
const inIframe = (() => {
  try {
    return window.self !== window.top;
  } catch {
    return true;
  }
})();
if (inIframe) return;
let userjs = self.userjs;
/**
 * Skip text/plain documents, based on uBlock Origin `vapi.js` file
 *
 * [source code](https://github.com/gorhill/uBlock/blob/68962453ff6eec7ff109615a738beb8699b9844a/platform/common/vapi.js#L35)
 */
if (
  (document instanceof Document ||
    (document instanceof XMLDocument && document.createElement('div') instanceof HTMLDivElement)) &&
  /^text\/html|^application\/(xhtml|xml)/.test(document.contentType || '') === true &&
  (self.userjs instanceof Object === false || userjs.UserJS !== true)
) {
  userjs = self.userjs = { UserJS: true };
} else {
  console.error('[%cMagic Userscript+%c] %cERROR','color: rgb(29, 155, 240);','','color: rgb(249, 24, 128);', `MIME type is not a document, got "${document.contentType || ''}"`);
}
if (!(typeof userjs === 'object' && userjs.UserJS)) return;
{
  /** Native implementation exists */
  const excludePolicy = [
    'outlook.office.com'
  ];
  const hostname = location?.hostname || '';
  if (window.trustedTypes && window.trustedTypes.createPolicy && !hostname.includes(excludePolicy)) window.trustedTypes.createPolicy('default', { createHTML: (string) => string, createScript: (string) => string, createScriptURL: (string) => string });
}
/** [i18n directory](https://github.com/magicoflolis/Userscript-Plus/tree/master/src/_locales) */
const translations = {
 'ar': {
  'createdby': 'انشأ من قبل',
  'name': 'اسم',
  'daily_installs': 'التثبيت اليومي',
  'close': 'يغلق',
  'filterA': 'منقي',
  'max': 'تحقيق أقصى قدر',
  'min': 'تصغير',
  'search': 'يبحث',
  'search_placeholder': 'بحث في البرامج النصية',
  'install': 'تثبيت',
  'issue': 'إصدار جديد',
  'version_number': 'الإصدار',
  'updated': 'آخر تحديث',
  'total_installs': 'إجمالي التثبيت',
  'ratings': 'التقييمات',
  'good': 'جيد',
  'ok': 'جيد',
  'bad': 'سيء',
  'created_date': 'تم إنشاؤه',
  'redirect': 'شوكة دهنية للكبار',
  'filter': 'تصفية اللغات الأخرى',
  'dtime': 'عرض المهلة',
  'save': 'حفظ',
  'reset': 'إعادة تعيين',
  'preview_code': 'كود المعاينة',
  'saveFile': 'احفظ الملف',
  'newTab': 'علامة تبويب جديدة',
  'applies_to': 'ينطبق على',
  'license': 'الترخيص',
  'no_license': 'لا يوجد',
  'antifeatures': 'إعلانات',
  'userjs_fullscreen': 'ملء الشاشة الكاملة التلقائي',
  'listing_none': '(لا يوجد)',
  'export_config': 'تهيئة التصدير',
  'export_theme': 'تصدير السمة',
  'import_config': 'استيراد تهيئة الاستيراد',
  'import_theme': 'استيراد النسق',
  'code_size': 'حجم الرمز',
  'prmpt_css': 'التثبيت كأسلوب المستخدم؟',
  'userjs_inject': 'حقن Userscript+',
  'userjs_close': 'إغلاق Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Code',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'de': {
  'createdby': 'Erstellt von',
  'name': 'Name',
  'daily_installs': 'Tägliche Installationen',
  'close': 'Schließen Sie',
  'filterA': 'Filter',
  'max': 'Maximieren Sie',
  'min': 'minimieren',
  'search': 'Suche',
  'search_placeholder': 'Suche nach Userscripts',
  'install': 'Installieren Sie',
  'issue': 'Neue Ausgabe',
  'version_number': 'Version',
  'updated': 'Zuletzt aktualisiert',
  'total_installs': 'Installationen insgesamt',
  'ratings': 'Bewertungen',
  'good': 'Gut',
  'ok': 'Okay',
  'bad': 'Schlecht',
  'created_date': 'Erstellt',
  'redirect': 'Greasy Fork für Erwachsene',
  'filter': 'Andere Sprachen herausfiltern',
  'dtime': 'Zeitüberschreitung anzeigen',
  'save': 'Speichern Sie',
  'reset': 'Zurücksetzen',
  'preview_code': 'Vorschau Code',
  'saveFile': 'Datei speichern',
  'newTab': 'Neue Registerkarte',
  'applies_to': 'Gilt für',
  'license': 'Lizenz',
  'no_license': 'N/A',
  'antifeatures': 'Antifeatures',
  'userjs_fullscreen': 'Automatischer Vollbildmodus',
  'listing_none': '(Keine)',
  'export_config': 'Konfig exportieren',
  'export_theme': 'Thema exportieren',
  'import_config': 'Konfig importieren',
  'import_theme': 'Thema importieren',
  'code_size': 'Code Größe',
  'prmpt_css': 'Als UserStyle installieren?',
  'userjs_inject': 'Userscript+ einfügen',
  'userjs_close': 'Userscript+ schließen',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Quelltext',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'en': {
  'createdby': 'Created by',
  'name': 'Name',
  'daily_installs': 'Daily Installs',
  'close': 'Close',
  'filterA': 'Filter',
  'max': 'Maximize',
  'min': 'Minimize',
  'search': 'Search',
  'search_placeholder': 'Search for userscripts',
  'install': 'Install',
  'issue': 'New Issue',
  'version_number': 'Version',
  'updated': 'Last Updated',
  'total_installs': 'Total Installs',
  'ratings': 'Ratings',
  'good': 'Good',
  'ok': 'Okay',
  'bad': 'Bad',
  'created_date': 'Created',
  'redirect': 'Greasy Fork for adults',
  'filter': 'Filter out other languages',
  'dtime': 'Display Timeout',
  'save': 'Save',
  'reset': 'Reset',
  'preview_code': 'Preview Code',
  'saveFile': 'Download',
  'newTab': 'New Tab',
  'applies_to': 'Applies to',
  'license': 'License',
  'no_license': 'N/A',
  'antifeatures': 'Antifeatures',
  'userjs_fullscreen': 'Automatic Fullscreen',
  'listing_none': '(None)',
  'export_config': 'Export Config',
  'export_theme': 'Export Theme',
  'import_config': 'Import Config',
  'import_theme': 'Import Theme',
  'code_size': 'Code Size',
  'prmpt_css': 'Install as UserStyle?',
  'userjs_inject': 'Inject Userscript+',
  'userjs_close': 'Close Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Code',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'en_GB': {
  'createdby': 'Created by',
  'name': 'Name',
  'daily_installs': 'Daily Installs',
  'close': 'Close',
  'filterA': 'Filter',
  'max': 'Maximize',
  'min': 'Minimize',
  'search': 'Search',
  'search_placeholder': 'Search for userscripts',
  'install': 'Install',
  'issue': 'New Issue',
  'version_number': 'Version',
  'updated': 'Last Updated',
  'total_installs': 'Total Installs',
  'ratings': 'Ratings',
  'good': 'Good',
  'ok': 'Okay',
  'bad': 'Bad',
  'created_date': 'Created',
  'redirect': 'Greasy Fork for adults',
  'filter': 'Filter out other languages',
  'dtime': 'Display Timeout',
  'save': 'Save',
  'reset': 'Reset',
  'preview_code': 'Preview Code',
  'saveFile': 'Download',
  'newTab': 'New Tab',
  'applies_to': 'Applies to',
  'license': 'License',
  'no_license': 'N/A',
  'antifeatures': 'Antifeatures',
  'userjs_fullscreen': 'Automatic Fullscreen',
  'listing_none': '(None)',
  'export_config': 'Export Config',
  'export_theme': 'Export Theme',
  'import_config': 'Import Config',
  'import_theme': 'Import Theme',
  'code_size': 'Code Size',
  'prmpt_css': 'Install as UserStyle?',
  'userjs_inject': 'Inject Userscript+',
  'userjs_close': 'Close Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Code',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'es': {
  'createdby': 'Creado por',
  'name': 'Nombre',
  'daily_installs': 'Instalaciones diarias',
  'close': 'Ya no se muestra',
  'filterA': 'Filtro',
  'max': 'Maximizar',
  'min': 'Minimizar',
  'search': 'Busque en',
  'search_placeholder': 'Buscar userscripts',
  'install': 'Instalar',
  'issue': 'Nueva edición',
  'version_number': 'Versión',
  'updated': 'Última actualización',
  'total_installs': 'Total de instalaciones',
  'ratings': 'Clasificaciones',
  'good': 'Bueno',
  'ok': 'Ok',
  'bad': 'Malo',
  'created_date': 'Creado',
  'redirect': 'Greasy Fork para adultos',
  'filter': 'Filtrar otros idiomas',
  'dtime': 'Mostrar el tiempo de espera',
  'save': 'Guardar',
  'reset': 'Reiniciar',
  'preview_code': 'Vista previa del código',
  'saveFile': 'Guardar archivo',
  'newTab': 'Guardar archivo',
  'applies_to': 'Se aplica a',
  'license': 'Licencia',
  'no_license': 'Desconocida',
  'antifeatures': 'Características indeseables',
  'userjs_fullscreen': 'Pantalla completa automática',
  'listing_none': '(Ninguno)',
  'export_config': 'Exportar configuración',
  'export_theme': 'Exportar tema',
  'import_config': 'Importar configuración',
  'import_theme': 'Importar tema',
  'code_size': 'Código Tamaño',
  'prmpt_css': '¿Instalar como UserStyle?',
  'userjs_inject': 'Inyectar Userscript+',
  'userjs_close': 'Cerrar Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Código',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'fr': {
  'createdby': 'Créé par',
  'name': 'Nom',
  'daily_installs': 'Installations quotidiennes',
  'close': 'Ne plus montrer',
  'filterA': 'Filtre',
  'max': 'Maximiser',
  'min': 'Minimiser',
  'search': 'Recherche',
  'search_placeholder': 'Rechercher des userscripts',
  'install': 'Installer',
  'issue': 'Nouveau numéro',
  'version_number': 'Version',
  'updated': 'Dernière mise à jour',
  'total_installs': 'Total des installations',
  'ratings': 'Notations',
  'good': 'Bon',
  'ok': 'Ok',
  'bad': 'Mauvais',
  'created_date': 'Créé',
  'redirect': 'Greasy Fork pour les adultes',
  'filter': 'Filtrer les autres langues',
  'dtime': "Délai d'affichage",
  'save': 'Sauvez',
  'reset': 'Réinitialiser',
  'preview_code': 'Prévisualiser le code',
  'saveFile': 'Enregistrer le fichier',
  'newTab': 'Nouvel onglet',
  'applies_to': "S'applique à",
  'license': 'Licence',
  'no_license': 'N/A',
  'antifeatures': 'Antifeatures',
  'userjs_fullscreen': 'Plein écran automatique',
  'listing_none': '(Aucun)',
  'export_config': 'Export Config',
  'export_theme': 'Exporter le thème',
  'import_config': 'Importer la configuration',
  'import_theme': 'Importer le thème',
  'code_size': 'Code Taille',
  'prmpt_css': 'Installer comme UserStyle ?',
  'userjs_inject': 'Injecter Userscript+',
  'userjs_close': 'Fermer Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Code',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'ja': {
  'createdby': 'によって作成された',
  'name': '名前',
  'daily_installs': 'デイリーインストール',
  'close': '表示されなくなりました',
  'filterA': 'フィルター',
  'max': '最大化',
  'min': 'ミニマム',
  'search': '検索',
  'search_placeholder': 'ユーザースクリプトの検索',
  'install': 'インストール',
  'issue': '新刊のご案内',
  'version_number': 'バージョン',
  'updated': '最終更新日',
  'total_installs': '総インストール数',
  'ratings': 'レーティング',
  'good': 'グッド',
  'ok': '良い',
  'bad': '悪い',
  'created_date': '作成',
  'redirect': '大人のGreasyfork',
  'filter': '他の言語をフィルタリングする',
  'dtime': '表示タイムアウト',
  'save': '拯救',
  'reset': 'リセット',
  'preview_code': 'コードのプレビュー',
  'saveFile': 'ファイルを保存',
  'newTab': '新しいタブ',
  'applies_to': '適用対象',
  'license': 'ライセンス',
  'no_license': '不明',
  'antifeatures': 'アンチ機能',
  'userjs_fullscreen': '自動フルスクリーン',
  'listing_none': '(なし)',
  'export_config': 'エクスポート設定',
  'export_theme': 'テーマのエクスポート',
  'import_config': '設定のインポート',
  'import_theme': 'テーマのインポート',
  'code_size': 'コード・サイズ',
  'prmpt_css': 'UserStyleとしてインストールしますか？',
  'userjs_inject': 'Userscript+ を挿入',
  'userjs_close': 'Userscript+ を閉じる',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'コード',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'nl': {
  'createdby': 'Gemaakt door',
  'name': 'Naam',
  'daily_installs': 'Dagelijkse Installaties',
  'close': 'Sluit',
  'filterA': 'Filter',
  'max': 'Maximaliseer',
  'min': 'Minimaliseer',
  'search': 'Zoek',
  'search_placeholder': 'Zoeken naar gebruikersscripts',
  'install': 'Installeer',
  'issue': 'Nieuw Issue',
  'version_number': 'Versie',
  'updated': 'Laatste Update',
  'total_installs': 'Totale Installaties',
  'ratings': 'Beoordeling',
  'good': 'Goed',
  'ok': 'Ok',
  'bad': 'Slecht',
  'created_date': 'Aangemaakt',
  'redirect': 'Greasy Fork voor volwassenen',
  'filter': 'Filter andere talen',
  'dtime': 'Weergave timeout',
  'save': 'Opslaan',
  'reset': 'Opnieuw instellen',
  'preview_code': 'Voorbeeldcode',
  'saveFile': 'Bestand opslaan',
  'newTab': 'Nieuw tabblad',
  'applies_to': 'Geldt voor',
  'license': 'Licentie',
  'no_license': 'N.v.t.',
  'antifeatures': 'Functies voor eigen gewin',
  'userjs_fullscreen': 'Automatisch volledig scherm',
  'listing_none': '(Geen)',
  'export_config': 'Configuratie exporteren',
  'export_theme': 'Thema exporteren',
  'import_config': 'Configuratie importeren',
  'import_theme': 'Thema importeren',
  'code_size': 'Code Grootte',
  'prmpt_css': 'Installeren als UserStyle?',
  'userjs_inject': 'Injecteer Userscript+',
  'userjs_close': 'Sluit Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Code',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'pl': {
  'createdby': 'Stworzony przez',
  'name': 'Nazwa',
  'daily_installs': 'Codzienne instalacje',
  'close': 'Zamknij',
  'filterA': 'Filtr',
  'max': 'Maksymalizuj',
  'min': 'Minimalizuj',
  'search': 'Wyszukiwanie',
  'search_placeholder': 'Wyszukiwanie skryptów użytkownika',
  'install': 'Instalacja',
  'issue': 'Nowy numer',
  'version_number': 'Wersja',
  'updated': 'Ostatnia aktualizacja',
  'total_installs': 'Łączna liczba instalacji',
  'ratings': 'Oceny',
  'good': 'Dobry',
  'ok': 'Ok',
  'bad': 'Zły',
  'created_date': 'Utworzony',
  'redirect': 'Greasy Fork dla dorosłych',
  'filter': 'Odfiltruj inne języki',
  'dtime': 'Limit czasu wyświetlania',
  'save': 'Zapisz',
  'reset': 'Reset',
  'preview_code': 'Kod podglądu',
  'saveFile': 'Zapisz plik',
  'newTab': 'Nowa karta',
  'applies_to': 'Dotyczy',
  'license': 'Licencja',
  'no_license': 'N/A',
  'antifeatures': 'Antywzorce',
  'userjs_fullscreen': 'Automatyczny pełny ekran',
  'listing_none': '(Brak)',
  'export_config': 'Konfiguracja eksportu',
  'export_theme': 'Motyw eksportu',
  'import_config': 'Importuj konfigurację',
  'import_theme': 'Importuj motyw',
  'code_size': 'Kod Rozmiar',
  'prmpt_css': 'Zainstalować jako UserStyle?',
  'userjs_inject': 'Wstrzyknij Userscript+',
  'userjs_close': 'Zamknij Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Kod',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'ru': {
  'createdby': 'Сделано',
  'name': 'Имя',
  'daily_installs': 'Ежедневные установки',
  'close': 'Больше не показывать',
  'filterA': 'Фильтр',
  'max': 'Максимизировать',
  'min': 'Минимизировать',
  'search': 'Поиск',
  'search_placeholder': 'Поиск юзерскриптов',
  'install': 'Установите',
  'issue': 'Новый выпуск',
  'version_number': 'Версия',
  'updated': 'Последнее обновление',
  'total_installs': 'Всего установок',
  'ratings': 'Рейтинги',
  'good': 'Хорошо',
  'ok': 'Хорошо',
  'bad': 'Плохо',
  'created_date': 'Создано',
  'redirect': 'Greasy Fork для взрослых',
  'filter': 'Отфильтровать другие языки',
  'dtime': 'Тайм-аут отображения',
  'save': 'Сохранить',
  'reset': 'Перезагрузить',
  'preview_code': 'Предварительный просмотр кода',
  'saveFile': 'Сохранить файл',
  'newTab': 'Новая вкладка',
  'applies_to': 'Применяется к',
  'license': 'Лицензия',
  'no_license': 'Недоступно',
  'antifeatures': 'Нежелательная функциональность',
  'userjs_fullscreen': 'Автоматический полноэкранный режим',
  'listing_none': '(нет)',
  'export_config': 'Экспорт конфигурации',
  'export_theme': 'Экспорт темы',
  'import_config': 'Импорт конфигурации',
  'import_theme': 'Импортировать тему',
  'code_size': 'Код Размер',
  'prmpt_css': 'Установить как UserStyle?',
  'userjs_inject': 'Вставить Userscript+',
  'userjs_close': 'Закрыть Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': 'Исходный код',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'zh': {
  'createdby': '由...制作',
  'name': '姓名',
  'daily_installs': '日常安装',
  'close': '不再显示',
  'filterA': '过滤器',
  'max': '最大化',
  'min': '最小化',
  'search': '搜索',
  'search_placeholder': '搜索用户脚本',
  'install': '安装',
  'issue': '新问题',
  'version_number': '版本',
  'updated': '最后更新',
  'total_installs': '总安装量',
  'ratings': '评级',
  'good': '好的',
  'ok': '好的',
  'bad': '不好',
  'created_date': '创建',
  'redirect': '大人的Greasyfork',
  'filter': '过滤掉其他语言',
  'dtime': '显示超时',
  'save': '拯救',
  'reset': '重置',
  'preview_code': '预览代码',
  'saveFile': '保存存档',
  'newTab': '新标签',
  'applies_to': '适用于',
  'license': '许可证',
  'no_license': '暂无',
  'antifeatures': '可能不受欢迎的功能',
  'userjs_fullscreen': '自动全屏',
  'listing_none': '(无)',
  'export_config': '导出配置',
  'export_theme': '导出主题',
  'import_config': '导入配置',
  'import_theme': '导入主题',
  'code_size': '代码 尺寸',
  'prmpt_css': '安装为用户风格？',
  'userjs_inject': '注入 Userscript+',
  'userjs_close': '关闭 Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': '代码',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'zh_CN': {
  'createdby': '由...制作',
  'name': '姓名',
  'daily_installs': '日常安装',
  'close': '不再显示',
  'filterA': '过滤器',
  'max': '最大化',
  'min': '最小化',
  'search': '搜索',
  'search_placeholder': '搜索用户脚本',
  'install': '安装',
  'issue': '新问题',
  'version_number': '版本',
  'updated': '最后更新',
  'total_installs': '总安装量',
  'ratings': '评级',
  'good': '好的',
  'ok': '好的',
  'bad': '不好',
  'created_date': '创建',
  'redirect': '大人的Greasyfork',
  'filter': '过滤掉其他语言',
  'dtime': '显示超时',
  'save': '拯救',
  'reset': '重置',
  'preview_code': '预览代码',
  'saveFile': '保存存档',
  'newTab': '新标签',
  'applies_to': '适用于',
  'license': '许可证',
  'no_license': '暂无',
  'antifeatures': '可能不受欢迎的功能',
  'userjs_fullscreen': '自动全屏',
  'listing_none': '(无)',
  'export_config': '导出配置',
  'export_theme': '导出主题',
  'import_config': '导入配置',
  'import_theme': '导入主题',
  'code_size': '代码 尺寸',
  'prmpt_css': '安装为用户风格？',
  'userjs_inject': '注入 Userscript+',
  'userjs_close': '关闭 Userscript+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': '代码',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 },
 'zh_TW': {
  'createdby': '由...制作',
  'name': '姓名',
  'daily_installs': '日常安装',
  'close': '不再显示',
  'filterA': '过滤器',
  'max': '最大化',
  'min': '最小化',
  'search': '搜索',
  'search_placeholder': '搜索用户脚本',
  'install': '安装',
  'issue': '新问题',
  'version_number': '版本',
  'updated': '最后更新',
  'total_installs': '总安装量',
  'ratings': '评级',
  'good': '好的',
  'ok': '好的',
  'bad': '不好',
  'created_date': '创建',
  'redirect': '大人的Greasyfork',
  'filter': '过滤掉其他语言',
  'dtime': '显示超时',
  'save': '拯救',
  'reset': '重置',
  'preview_code': '预览代码',
  'saveFile': '保存存档',
  'newTab': '新标签',
  'applies_to': '适用于',
  'license': '许可证',
  'no_license': '暂无',
  'antifeatures': '可能不受欢迎的功能',
  'userjs_fullscreen': '自动全屏',
  'listing_none': '(无)',
  'export_config': '导出配置',
  'export_theme': '导出主题',
  'import_config': '导入配置',
  'import_theme': '导入主题',
  'code_size': '代码 尺寸',
  'prmpt_css': '作為使用者樣式安裝？',
  'userjs_inject': '注入用戶腳本+',
  'userjs_close': '關閉用戶腳本+',
  'userjs_sync': 'Sync',
  'userjs_autoinject': 'Inject on load',
  'auto_fetch': 'Fetch on load',
  'code': '代碼',
  'metadata': 'Metadata',
  'preview_metadata': 'Preview Metadata',
  'recommend_author': 'Recommend Author',
  'recommend_other': 'Recommend Others',
  'default_sort': 'Default Sort'
 }
};
/** [source code](https://github.com/magicoflolis/Userscript-Plus/blob/master/src/sass/_main.scss) */
const main_css = `mujs-root {
  --mujs-even-row: hsl(222, 14%, 22%);
  --mujs-odd-row: hsl(222, 14%, 11%);
  --mujs-even-err: hsl(0, 100%, 22%);
  --mujs-odd-err: hsl(0, 100%, 11%);
  --mujs-background-color: hsl(222, 14%, 33%);
  --mujs-gf-color: hsl(204, 100%, 40%);
  --mujs-sf-color: hsl(12, 86%, 50%);
  --mujs-border-b-color: hsla(0, 0%, 0%, 0);
  --mujs-gf-btn-color: hsl(211, 87%, 56%);
  --mujs-sf-btn-color: hsl(12, 86%, 50%);
  --mujs-sf-txt-color: hsl(12, 79%, 55%);
  --mujs-txt-color: hsl(0, 0%, 100%);
  --mujs-chck-color: hsla(0, 0%, 100%, 0.568);
  --mujs-chck-gf: hsla(197, 100%, 50%, 0.568);
  --mujs-chck-git: hsla(213, 13%, 16%, 0.568);
  --mujs-chck-open: hsla(12, 86%, 50%, 0.568);
  --mujs-placeholder: hsl(81, 56%, 54%);
  --mujs-position-top: unset;
  --mujs-position-bottom: 1em;
  --mujs-position-left: unset;
  --mujs-position-right: 1em;
  --mujs-font-family: Arial, Helvetica, sans-serif;
  font-family: var(--mujs-font-family, Arial, Helvetica, sans-serif);
  text-rendering: optimizeLegibility;
  word-break: normal;
  font-size: 14px;
  color: var(--mujs-txt-color, hsl(0, 0%, 100%));
}

mujs-root * {
  -webkit-appearance: none;
  -moz-appearance: none;
  appearance: none;
  scrollbar-color: var(--mujs-txt-color, hsl(0, 0%, 100%)) hsl(224, 14%, 21%);
  scrollbar-width: thin;
}
@supports not (scrollbar-width: thin) {
  mujs-root * ::-webkit-scrollbar {
    width: 1.4vw;
    height: 3.3vh;
  }
  mujs-root * ::-webkit-scrollbar-track {
    background-color: hsl(224, 14%, 21%);
    border-radius: 16px;
    margin-top: 3px;
    margin-bottom: 3px;
    box-shadow: inset 0 0 6px hsla(0, 0%, 0%, 0.3);
  }
  mujs-root * ::-webkit-scrollbar-thumb {
    border-radius: 16px;
    background-color: var(--mujs-txt-color, hsl(0, 0%, 100%));
    background-image: -webkit-linear-gradient(45deg, hsla(0, 0%, 100%, 0.2) 25%, transparent 25%, transparent 50%, hsla(0, 0%, 100%, 0.2) 50%, hsla(0, 0%, 100%, 0.2) 75%, transparent 75%, transparent);
  }
  mujs-root * ::-webkit-scrollbar-thumb:hover {
    background: var(--mujs-txt-color, hsl(0, 0%, 100%));
  }
}

mu-js {
  line-height: normal;
}

mujs-section > label,
.mujs-homepag e,
td.mujs-list,
.install {
  font-size: 16px;
}

.install,
.mujs-homepage {
  font-weight: 700;
}

mujs-section > label,
td.mujs-list {
  font-weight: 500;
}

.mujs-invalid {
  border-radius: 8px !important;
  border-width: 2px !important;
  border-style: solid !important;
  border-color: hsl(0, 100%, 50%) !important;
}

mujs-tabs,
mujs-column,
mujs-row,
.mujs-sty-flex {
  display: flex;
}

mujs-column,
mujs-row {
  gap: 0.5em;
}

mujs-column count-frame[data-counter=greasyfork] {
  background: var(--mujs-gf-color, hsl(204, 100%, 40%));
}
mujs-column count-frame[data-counter=sleazyfork] {
  background: var(--mujs-sf-color, hsl(12, 86%, 50%));
}
mujs-column count-frame[data-counter=github] {
  background: hsl(213, 13%, 16%);
}
mujs-column count-frame[data-counter=openuserjs] {
  background: hsla(12, 86%, 50%, 0.568);
}
@media screen and (max-width: 800px) {
  mujs-column {
    flex-flow: row wrap;
  }
}

mujs-row {
  flex-flow: column wrap;
}

mu-js {
  cursor: default;
}

.hidden {
  display: none !important;
  z-index: -1 !important;
}

mujs-main {
  width: 100%;
  width: -moz-available;
  width: -webkit-fill-available;
  background: var(--mujs-background-color, hsl(222, 14%, 33%)) !important;
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
  border-radius: 16px;
}
@media screen and (max-height: 720px) {
  mujs-main:not(.webext-page) {
    height: 100% !important;
    bottom: 0rem !important;
    right: 0rem !important;
    margin: 0rem !important;
  }
}
mujs-main.expanded {
  height: 100% !important;
  bottom: 0rem !important;
}
mujs-main:not(.webext-page) {
  position: fixed;
  height: 492px;
}
mujs-main:not(.webext-page):not(.expanded) {
  margin-left: 1rem;
  margin-right: 1rem;
  right: 1rem;
  bottom: 1rem;
}
mujs-main:not(.hidden) {
  z-index: 100000000000000000 !important;
  display: flex !important;
  flex-direction: column !important;
}
mujs-main > * {
  width: 100%;
  width: -moz-available;
  width: -webkit-fill-available;
}
mujs-main mujs-toolbar {
  order: 0;
  padding: 0.5em;
  display: flex;
  place-content: space-between;
}
mujs-main mujs-toolbar mujs-tabs {
  overflow: hidden;
  order: 0;
}
mujs-main mujs-toolbar mujs-column {
  flex-flow: row nowrap;
  order: 999999999999;
}
mujs-main mujs-toolbar > * {
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
}
mujs-main mujs-tabs {
  gap: 0.5em;
  text-align: center;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
  flex-flow: row wrap;
}
mujs-main mujs-tabs mujs-tab {
  padding: 0.25em;
  min-width: 150px;
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
  height: -webkit-fit-content;
  height: -moz-fit-content;
  height: fit-content;
  display: flex;
  place-content: space-between;
  border: 1px solid transparent;
  border-radius: 4px;
  background: transparent;
}
@media screen and (max-width: 800px) {
  mujs-main mujs-tabs mujs-tab {
    min-width: 6em !important;
  }
}
mujs-main mujs-tabs mujs-tab.active {
  background: var(--mujs-even-row, hsl(222, 14%, 18%));
}
mujs-main mujs-tabs mujs-tab:not(.active):hover {
  background: var(--mujs-even-row, hsl(222, 14%, 18%));
}
mujs-main mujs-tabs mujs-tab mujs-host {
  float: left;
  overflow: auto;
  overflow-wrap: break-word;
  text-overflow: ellipsis;
  white-space: nowrap;
}
mujs-main mujs-tabs mujs-tab mu-js {
  float: right;
}
mujs-main mujs-tabs mujs-addtab {
  order: 999999999999;
  font-size: 20px;
  padding: 0px 0.25em;
}
mujs-main mujs-tabs mujs-addtab:hover {
  background: var(--mujs-even-row, hsl(222, 14%, 18%));
}
mujs-main mujs-tab,
mujs-main mujs-btn,
mujs-main input {
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
  height: -webkit-fit-content;
  height: -moz-fit-content;
  height: fit-content;
}
mujs-main input {
  background: hsla(0, 0%, 0%, 0);
  color: var(--mujs-txt-color, hsl(0, 0%, 100%));
}
mujs-main input:not([type=checkbox]) {
  border: transparent;
  outline: none !important;
}
mujs-main mujs-page,
mujs-main textarea {
  background: inherit;
  overflow-y: auto;
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
  border-radius: 5px;
  outline: none;
  font-family: monospace;
  font-size: 14px;
}
mujs-main mujs-page {
  padding: 0.5em;
  margin: 0.5em;
}
mujs-main textarea {
  overflow-y: auto;
  color: var(--mujs-placeholder, hsl(81, 56%, 54%));
  resize: vertical;
}
mujs-main textarea:focus {
  outline: none;
}
mujs-main th,
mujs-main .mujs-cfg *:not(input[type=password], input[type=text], input[type=number]) {
  -webkit-user-select: none !important;
  -moz-user-select: none !important;
  -ms-user-select: none !important;
  user-select: none !important;
}
mujs-main .mujs-footer {
  order: 3;
  overflow-x: hidden;
  text-align: center;
  border-radius: 16px;
}
mujs-main .mujs-footer > * {
  min-height: 50px;
}
mujs-main .mujs-footer .error:nth-child(even) {
  background: var(--mujs-even-err, hsl(0, 100%, 22%)) !important;
}
mujs-main .mujs-footer .error:nth-child(odd) {
  background: var(--mujs-odd-err, hsl(0, 100%, 11%)) !important;
}
mujs-main .mujs-prompt {
  align-items: center;
  justify-content: center;
}
mujs-main .mujs-prompt svg {
  width: 14px;
  height: 14px;
  background: transparent;
}
mujs-main .mujs-prompt > .prompt {
  position: absolute;
  background: var(--mujs-background-color, hsl(222, 14%, 33%)) !important;
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
  border-radius: 16px;
  text-align: center;
  padding: 0.5em;
  z-index: 1;
}
mujs-main .mujs-prompt > .prompt .prompt-head {
  font-size: 18px;
}
mujs-main .mujs-prompt > .prompt .prompt-body {
  display: grid;
  grid-auto-flow: column;
  grid-gap: 0.5em;
  padding-top: 0.5em;
}
mujs-main .mujs-prompt > .prompt mujs-btn.prompt-deny {
  background: var(--mujs-sf-btn-color, hsl(12, 86%, 50%));
  border-color: var(--mujs-sf-btn-color, hsl(12, 86%, 50%));
}
mujs-main .mujs-prompt > .prompt mujs-btn.prompt-deny:hover {
  background: var(--mujs-sf-txt-color, hsl(12, 79%, 55%));
  border-color: var(--mujs-sf-txt-color, hsl(12, 79%, 55%));
}
mujs-main .mujs-prompt > .prompt mujs-btn.prompt-confirm {
  background: var(--mujs-gf-color, hsl(204, 100%, 40%));
  border-color: var(--mujs-gf-color, hsl(204, 100%, 40%));
}
mujs-main .mujs-prompt > .prompt mujs-btn.prompt-confirm:hover {
  background: var(--mujs-gf-btn-color, hsl(211, 87%, 56%));
  border-color: var(--mujs-gf-btn-color, hsl(211, 87%, 56%));
}

.mainframe {
  background: transparent;
  position: fixed;
  bottom: var(--mujs-position-bottom, 1rem);
  right: var(--mujs-position-right, 1rem);
  top: var(--mujs-position-top, unset);
  left: var(--mujs-position-left, unset);
}
.mainframe count-frame {
  width: fit-content;
  width: -moz-fit-content;
  width: -webkit-fit-content;
  height: auto;
  padding: 14px 16px;
}
.mainframe.error {
  opacity: 1 !important;
}
.mainframe.error count-frame {
  background: var(--mujs-even-err, hsl(0, 100%, 22%)) !important;
}
.mainframe:not(.hidden) {
  z-index: 100000000000000000 !important;
  display: block;
}

count-frame {
  border-radius: 1000px;
  margin: 0px 3px;
  padding: 4px 6px;
  border: 2px solid var(--mujs-border-b-color, hsla(0, 0%, 0%, 0));
  font-size: 16px;
  font-weight: 400;
  display: inline-block;
  text-align: center;
  min-width: 1em;
  background: var(--mujs-background-color, hsl(222, 14%, 33%));
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
}

mujs-header {
  order: 1;
  display: flex;
  border-bottom: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
  padding-left: 0.5em;
  padding-right: 0.5em;
  padding-bottom: 0.5em;
  font-size: 1em;
  place-content: space-between;
  height: fit-content;
  height: -moz-fit-content;
  height: -webkit-fit-content;
  gap: 1em;
}
mujs-header > *:not(mujs-url) {
  height: fit-content;
  height: -moz-fit-content;
  height: -webkit-fit-content;
}
mujs-header mujs-url {
  order: 0;
  flex-grow: 1;
}
mujs-header mujs-url > input {
  width: 100%;
  height: 100%;
  background: var(--mujs-even-row, hsl(222, 14%, 18%));
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
  border-radius: 4px;
}
mujs-header .rate-container {
  order: 1;
}
mujs-header .btn-frame {
  order: 999999999999;
}

mujs-body {
  order: 2;
  overflow-x: hidden;
  padding: 0px;
  height: 100%;
  border: 1px solid var(--mujs-border-b-color, hsla(0, 0%, 0%, 0));
  border-bottom-left-radius: 16px;
  border-bottom-right-radius: 16px;
}
mujs-body .mujs-ratings {
  padding: 0 0.25em;
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
  border-radius: 1000px;
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
}
mujs-body mu-jsbtn {
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
}
mujs-body table,
mujs-body th,
mujs-body td {
  border-collapse: collapse;
}
mujs-body table {
  width: 100%;
  width: -moz-available;
  width: -webkit-fill-available;
}
@media screen and (max-width: 1180px) {
  mujs-body table thead > tr {
    display: table-column;
  }
  mujs-body table .frame:not(.webext-page) {
    width: 100%;
    display: flex;
    flex-flow: row wrap;
    align-items: center;
    padding-top: 0.5em;
    padding-bottom: 0.5em;
  }
  mujs-body table .frame:not(.webext-page) td {
    margin: auto;
  }
  mujs-body table .frame:not(.webext-page) td > mujs-a,
  mujs-body table .frame:not(.webext-page) td > mu-js,
  mujs-body table .frame:not(.webext-page) td > mujs-column {
    text-align: center;
    justify-content: center;
  }
  mujs-body table .frame:not(.webext-page) td > mujs-a {
    width: 100%;
  }
}
@media screen and (max-width: 1180px) and (max-width: 800px) {
  mujs-body table .frame:not(.webext-page) td > mujs-column {
    flex-flow: column wrap;
  }
  mujs-body table .frame:not(.webext-page) td > mujs-column > mujs-row {
    align-content: center;
  }
  mujs-body table .frame:not(.webext-page) td > mujs-column mujs-column {
    justify-content: center;
  }
}
@media screen and (max-width: 1180px) {
  mujs-body table .frame:not(.webext-page) td:not(.mujs-name, .install-btn) {
    width: 25%;
  }
}
@media screen and (max-width: 1180px) and (max-width: 800px) {
  mujs-body table .frame:not(.webext-page) td.install-btn {
    width: 100%;
  }
}
@media screen and (max-width: 1180px) {
  mujs-body table .frame:not(.webext-page) .mujs-name {
    width: 100%;
  }
}
@media screen and (max-width: 550px) {
  mujs-body table .frame:not(.webext-page) td {
    margin: 1rem !important;
  }
  mujs-body table .frame:not(.webext-page) td:not(.mujs-name, .install-btn) {
    width: auto !important;
  }
}
mujs-body table th {
  position: -webkit-sticky;
  position: sticky;
  top: 0;
  background: hsla(222, 14%, 33%, 0.75);
  border-bottom: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
}
mujs-body table th.mujs-header-name {
  width: 50%;
}
@media screen and (max-width: 800px) {
  mujs-body table th.mujs-header-name {
    width: auto !important;
  }
}
mujs-body table .frame:nth-child(even) {
  background: var(--mujs-even-row, hsl(222, 14%, 18%)) !important;
}
mujs-body table .frame:nth-child(even) textarea {
  background: var(--mujs-odd-row, hsl(222, 14%, 33%)) !important;
}
mujs-body table .frame:nth-child(odd) {
  background: var(--mujs-odd-row, hsl(222, 14%, 33%)) !important;
}
mujs-body table .frame:nth-child(odd) textarea {
  background: var(--mujs-even-row, hsl(222, 14%, 18%)) !important;
}
mujs-body table .frame:not([data-engine=sleazyfork], [data-engine=greasyfork]) mujs-a {
  color: var(--mujs-sf-txt-color, hsl(12, 79%, 55%));
}
mujs-body table .frame:not([data-engine=sleazyfork], [data-engine=greasyfork]) mu-jsbtn {
  background: var(--mujs-sf-btn-color, hsl(12, 86%, 50%));
  border-color: var(--mujs-sf-btn-color, hsl(12, 86%, 50%));
}
mujs-body table .frame:not([data-engine=sleazyfork], [data-engine=greasyfork]) mu-jsbtn:hover {
  background: var(--mujs-sf-txt-color, hsl(12, 79%, 55%));
  border-color: var(--mujs-sf-txt-color, hsl(12, 79%, 55%));
}
mujs-body table .frame[data-engine=sleazyfork] mujs-a, mujs-body table .frame[data-engine=greasyfork] mujs-a {
  color: var(--mujs-gf-color, hsl(197, 100%, 50%));
}
mujs-body table .frame[data-engine=sleazyfork] mujs-a:hover, mujs-body table .frame[data-engine=greasyfork] mujs-a:hover {
  color: var(--mujs-gf-btn-color, hsl(211, 87%, 56%));
}
mujs-body table .frame[data-engine=sleazyfork] mu-jsbtn, mujs-body table .frame[data-engine=greasyfork] mu-jsbtn {
  background: var(--mujs-gf-color, hsl(204, 100%, 40%));
  border-color: var(--mujs-gf-color, hsl(204, 100%, 40%));
}
mujs-body table .frame[data-engine=sleazyfork] mu-jsbtn:hover, mujs-body table .frame[data-engine=greasyfork] mu-jsbtn:hover {
  background: var(--mujs-gf-btn-color, hsl(211, 87%, 56%));
  border-color: var(--mujs-gf-btn-color, hsl(211, 87%, 56%));
}
mujs-body table .frame[data-good] mujs-a, mujs-body table .frame[data-author] mujs-a {
  color: var(--mujs-placeholder, hsl(81, 56%, 54%));
}
mujs-body table .frame[data-good] mujs-a:hover, mujs-body table .frame[data-author] mujs-a:hover {
  color: hsl(81, 56%, 43%);
}
mujs-body table .frame[data-good] .mujs-list, mujs-body table .frame[data-author] .mujs-list {
  color: hsl(0, 0%, 100%);
}
mujs-body table .frame[data-good] mu-jsbtn, mujs-body table .frame[data-author] mu-jsbtn {
  color: hsl(215, 47%, 24%);
  background: var(--mujs-placeholder, hsl(81, 56%, 54%));
  border-color: var(--mujs-placeholder, hsl(81, 56%, 54%));
}
mujs-body table .frame[data-good] mu-jsbtn:hover, mujs-body table .frame[data-author] mu-jsbtn:hover {
  background: hsl(81, 56%, 65%);
  border-color: hsl(81, 56%, 65%);
}
mujs-body table .frame.translated:not([data-good], [data-author]) mujs-a {
  color: hsl(249, 56%, 65%);
}
mujs-body table .frame.translated:not([data-good], [data-author]) mujs-a:hover {
  color: hsl(249, 56%, 85%);
}
mujs-body table .frame.translated:not([data-good], [data-author]) mu-jsbtn {
  color: hsl(215, 47%, 85%);
  background: hsl(249, 56%, 65%);
  border-color: hsl(249, 56%, 65%);
}
mujs-body table .frame.translated:not([data-good], [data-author]) mu-jsbtn:hover {
  background: hsl(249, 56%, 65%);
  border-color: hsl(249, 56%, 65%);
}
mujs-body table .frame .mujs-ratings[data-el=good] {
  border-color: hsl(120, 50%, 40%);
  background-color: hsla(120, 50%, 40%, 0.102);
  color: hsl(120, 100%, 60%);
}
mujs-body table .frame .mujs-ratings[data-el=ok] {
  border-color: hsl(60, 100%, 30%);
  background-color: hsla(60, 100%, 30%, 0.102);
  color: hsl(60, 100%, 50%);
}
mujs-body table .frame .mujs-ratings[data-el=bad] {
  border-color: hsl(0, 100%, 30%);
  background-color: hsla(0, 50%, 40%, 0.102);
  color: hsl(0, 100%, 50%);
}
mujs-body table .frame svg {
  width: 12px;
  height: 12px;
  fill: currentColor;
  background: transparent;
}
mujs-body table .frame > td:not(.mujs-name) {
  text-align: center;
}
mujs-body table .frame > .mujs-name > mujs-a {
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
}
mujs-body table .frame > .mujs-name mu-jsbtn,
mujs-body table .frame > .mujs-name mu-js {
  height: -webkit-fit-content;
  height: -moz-fit-content;
  height: fit-content;
}
mujs-body table .frame > .mujs-name > mu-jsbtn {
  margin: auto;
}
mujs-body table .frame > .mujs-name > mujs-column > mu-jsbtn {
  padding: 0px 7px;
}
@media screen and (max-width: 800px) {
  mujs-body table .frame > .mujs-name > mujs-column > mu-jsbtn {
    width: 100%;
  }
}
mujs-body table .frame > .mujs-uframe > mujs-a {
  font-size: 16px;
  font-weight: 500;
  padding-left: 0.5rem;
  padding-right: 0.5rem;
}
mujs-body table .frame [data-el=more-info] > mujs-row {
  gap: 0.25em;
}
mujs-body table .frame [data-el=matches] {
  gap: 0.25em;
  max-width: 40em;
}
mujs-body table .frame [data-el=matches] .mujs-grants {
  display: inline-flex;
  flex-flow: row wrap;
  overflow: auto;
  overflow-wrap: break-word;
  text-overflow: ellipsis;
  white-space: nowrap;
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
  max-height: 5em;
  gap: 0.2em;
}
mujs-body table .frame [data-el=matches] .mujs-grants > mujs-a {
  display: inline;
}
mujs-body table .frame [data-el=matches] .mujs-grants > mujs-a:not([data-command]) {
  cursor: default !important;
  color: var(--mujs-txt-color, hsl(0, 0%, 100%));
}
mujs-body table .frame [data-el=matches] .mujs-grants > mujs-a::after {
  content: ", ";
  color: var(--mujs-txt-color, hsl(0, 0%, 100%));
}
mujs-body table .frame [data-el=matches] .mujs-grants > mujs-a:last-child::after {
  content: "";
}
@media screen and (max-width: 800px) {
  mujs-body table .frame [data-el=matches] {
    align-self: center;
    width: 30em !important;
  }
}
mujs-body table .frame [data-name=license] {
  text-overflow: ellipsis;
  overflow: hidden;
  white-space: nowrap;
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
}
@media screen and (max-width: 800px) {
  mujs-body table .frame [data-name=license] {
    width: 100% !important;
    width: -moz-available !important;
    width: -webkit-fill-available !important;
  }
}

@media screen and (max-width: 1150px) {
  .mujs-cfg {
    margin: 0px auto 1rem auto !important;
  }
}
.mujs-cfg {
  height: fit-content;
  height: -moz-fit-content;
  height: -webkit-fit-content;
}
.mujs-cfg mujs-section {
  border-radius: 16px;
  padding: 0.5em;
}
.mujs-cfg mujs-section:nth-child(even) {
  background: var(--mujs-even-row, hsl(222, 14%, 18%)) !important;
}
.mujs-cfg mujs-section:nth-child(even) input,
.mujs-cfg mujs-section:nth-child(even) select {
  background: var(--mujs-odd-row, hsl(222, 14%, 33%));
}
.mujs-cfg mujs-section:nth-child(even) select option {
  background: var(--mujs-odd-row, hsl(222, 14%, 33%));
}
.mujs-cfg mujs-section:nth-child(even) select option:hover {
  background: var(--mujs-even-row, hsl(222, 14%, 18%)) !important;
}
.mujs-cfg mujs-section:nth-child(odd) {
  background: var(--mujs-odd-row, hsl(222, 14%, 33%)) !important;
}
.mujs-cfg mujs-section:nth-child(odd) input,
.mujs-cfg mujs-section:nth-child(odd) select {
  background: var(--mujs-even-row, hsl(222, 14%, 18%));
}
.mujs-cfg mujs-section:nth-child(odd) select option {
  background: var(--mujs-even-row, hsl(222, 14%, 18%));
}
.mujs-cfg mujs-section:nth-child(odd) select option:hover {
  background: var(--mujs-odd-row, hsl(222, 14%, 33%)) !important;
}
.mujs-cfg mujs-section[data-name=theme] .sub-section {
  border-radius: 4px;
}
.mujs-cfg mujs-section[data-name=theme] .sub-section:nth-child(even) {
  background: var(--mujs-even-row, hsl(222, 14%, 18%));
}
.mujs-cfg mujs-section[data-name=theme] .sub-section:nth-child(odd) {
  background: var(--mujs-odd-row, hsl(222, 14%, 33%));
}
.mujs-cfg mujs-section[data-name=theme] input,
.mujs-cfg mujs-section[data-name=theme] select {
  background: inherit;
}
.mujs-cfg mujs-section[data-name=theme] select option {
  background: inherit;
}
.mujs-cfg mujs-section[data-name=theme] select option:hover {
  background: var(--mujs-even-row, hsl(222, 14%, 18%)) !important;
}
.mujs-cfg mujs-section svg {
  width: 14px;
  height: 14px;
  fill: currentColor;
  background: transparent;
}
.mujs-cfg mujs-section[data-name=exp], .mujs-cfg mujs-section[data-name=blacklist] {
  display: flex;
  justify-content: space-between;
  flex-direction: column;
  gap: 0.25em;
}
.mujs-cfg mujs-section[data-name=exp] > mujs-btn, .mujs-cfg mujs-section[data-name=blacklist] > mujs-btn {
  width: 100%;
  width: -moz-available;
  width: -webkit-fill-available;
}
.mujs-cfg mujs-section[data-name=exp] > mujs-btn:hover, .mujs-cfg mujs-section[data-name=blacklist] > mujs-btn:hover {
  background: var(--mujs-even-row, hsl(222, 14%, 18%)) !important;
}
.mujs-cfg mujs-section input[type=text]::-webkit-input-placeholder {
  color: var(--mujs-placeholder, hsl(81, 56%, 54%));
}
.mujs-cfg mujs-section input[type=text]::-moz-placeholder {
  color: var(--mujs-placeholder, hsl(81, 56%, 54%));
}
.mujs-cfg mujs-section input[type=text]:-ms-input-placeholder {
  color: var(--mujs-placeholder, hsl(81, 56%, 54%));
}
.mujs-cfg mujs-section input[type=text]::-ms-input-placeholder {
  color: var(--mujs-placeholder, hsl(81, 56%, 54%));
}
.mujs-cfg mujs-section input[type=text]::placeholder {
  color: var(--mujs-placeholder, hsl(81, 56%, 54%));
}
.mujs-cfg mujs-section > label:not([data-blacklist]) {
  display: flex;
  justify-content: space-between;
}
.mujs-cfg mujs-section > label[data-blacklist] {
  display: grid;
  grid-auto-flow: column;
}
.mujs-cfg mujs-section > label[data-blacklist]:not(.new-list) {
  grid-template-columns: repeat(2, 1fr);
}
.mujs-cfg mujs-section > label.new-list {
  order: 999999999999;
}
.mujs-cfg mujs-section > label.new-list mujs-add {
  font-size: 20px;
}
.mujs-cfg mujs-section > label input:not([type=checkbox]) {
  font-size: 14px;
  position: relative;
  border-radius: 4px;
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
}
.mujs-cfg mujs-section select,
.mujs-cfg mujs-section select option {
  color: var(--mujs-txt-color, hsl(0, 0%, 100%));
  border: 1px solid transparent;
  list-style: none;
  outline-style: none;
  pointer-events: auto;
}
.mujs-cfg mujs-section select {
  text-align: center;
  border-radius: 4px;
}
.mujs-cfg mujs-section > *.sub-section {
  padding: 0.2em;
}
.mujs-cfg mujs-section > *.sub-section[data-engine] {
  flex-wrap: wrap;
}
.mujs-cfg mujs-section > *.sub-section[data-engine] input {
  width: 100%;
  width: -moz-available;
  width: -webkit-fill-available;
}
.mujs-cfg mujs-section > *.sub-section input[type=text] {
  margin: 0.2em 0px;
}
.mujs-cfg .mujs-inlab {
  position: relative;
  width: 38px;
}
.mujs-cfg .mujs-inlab input[type=checkbox] {
  display: none;
}
.mujs-cfg .mujs-inlab input[type=checkbox]:checked + label {
  margin-left: 0;
  background: var(--mujs-chck-color, hsla(0, 0%, 100%, 0.568));
}
.mujs-cfg .mujs-inlab input[type=checkbox]:checked + label:before {
  right: 0px;
}
.mujs-cfg .mujs-inlab input[type=checkbox][data-name=greasyfork]:checked + label {
  background: var(--mujs-gf-color, hsl(204, 100%, 40%));
}
.mujs-cfg .mujs-inlab input[type=checkbox][data-name=sleazyfork]:checked + label {
  background: var(--mujs-sf-color, hsl(12, 86%, 50%));
}
.mujs-cfg .mujs-inlab input[type=checkbox][data-name=openuserjs]:checked + label {
  background: var(--mujs-chck-open, hsla(12, 86%, 50%, 0.568));
}
.mujs-cfg .mujs-inlab input[type=checkbox][data-name=github]:checked + label {
  background: var(--mujs-chck-git, hsla(213, 13%, 16%, 0.568));
}
.mujs-cfg .mujs-inlab label {
  padding: 0;
  display: block;
  overflow: hidden;
  height: 16px;
  border-radius: 20px;
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
}
.mujs-cfg .mujs-inlab label:before {
  content: "";
  display: block;
  width: 20px;
  height: 20px;
  margin: -2px;
  background: var(--mujs-txt-color, hsl(0, 0%, 100%));
  position: absolute;
  top: 0;
  right: 20px;
  border-radius: 20px;
}
.mujs-cfg .mujs-sty-flex mujs-btn {
  margin: auto;
}
.mujs-cfg .mujs-sty-flex mujs-btn[data-command=reset] {
  background: var(--mujs-sf-btn-color, hsl(12, 86%, 50%));
  border-color: var(--mujs-sf-btn-color, hsl(12, 86%, 50%));
}
.mujs-cfg .mujs-sty-flex mujs-btn[data-command=reset]:hover {
  background: var(--mujs-sf-txt-color, hsl(12, 79%, 55%));
  border-color: var(--mujs-sf-txt-color, hsl(12, 79%, 55%));
}
.mujs-cfg .mujs-sty-flex mujs-btn[data-command=save] {
  background: var(--mujs-gf-color, hsl(204, 100%, 40%));
  border-color: var(--mujs-gf-color, hsl(204, 100%, 40%));
}
.mujs-cfg .mujs-sty-flex mujs-btn[data-command=save]:hover {
  background: var(--mujs-gf-btn-color, hsl(211, 87%, 56%));
  border-color: var(--mujs-gf-btn-color, hsl(211, 87%, 56%));
}
.mujs-cfg:not(.webext-page) {
  margin: 1rem 25rem;
}
@media screen and (max-height: 720px) {
  .mujs-cfg:not(.webext-page) {
    height: 100%;
    height: -moz-available;
    height: -webkit-fill-available;
    width: 100%;
    width: -moz-available;
    width: -webkit-fill-available;
    overflow-x: auto;
    padding: 0.5em;
  }
}

mujs-a {
  display: inline-block;
}

.mujs-name {
  display: flex;
  flex-flow: column wrap;
  gap: 0.5em;
}
.mujs-name span {
  font-size: 0.8em !important;
}

mujs-btn {
  font-style: normal;
  font-weight: 500;
  font-variant: normal;
  text-transform: none;
  text-rendering: auto;
  text-align: center;
  border: 1px solid var(--mujs-txt-color, hsl(0, 0%, 100%));
  font-size: 16px;
  border-radius: 4px;
  line-height: 1;
  padding: 6px 15px;
}
mujs-btn svg {
  width: 14px;
  height: 14px;
  fill: var(--mujs-txt-color, hsl(0, 0%, 100%));
}

mu-jsbtn {
  font-size: 14px;
  border-radius: 4px;
  font-style: normal;
  padding: 7px 15%;
  font-weight: 400;
  font-variant: normal;
  line-height: normal;
  display: block;
  text-align: center;
}

mujs-a,
mu-jsbtn,
.mujs-pointer,
.mujs-cfg mujs-section *:not(input[type=text], input[type=number], [data-theme], [data-blacklist]),
.mainbtn,
.mainframe,
mujs-btn {
  cursor: pointer !important;
}`;
/******************************************************************************/
// #region Console
const con = {
  title: '[%cMagic Userscript+%c]',
  color: 'color: rgb(29, 155, 240);',
  dbg(...msg) {
    const dt = new Date();
    console.debug(
      `${con.title} %cDBG`,
      con.color,
      '',
      'color: rgb(255, 212, 0);',
      `[${dt.getHours()}:${('0' + dt.getMinutes()).slice(-2)}:${('0' + dt.getSeconds()).slice(-2)}]`,
      ...msg
    );
  },
  err(...msg) {
    console.error(`${con.title} %cERROR`, con.color, '', 'color: rgb(249, 24, 128);', ...msg);
    const a = typeof alert !== 'undefined' && alert;
    const t = con.title.replace(/%c/g, '');
    for (const ex of msg) {
      if (typeof ex === 'object' && 'cause' in ex && a) {
        a(`${t} (${ex.cause}) ${ex.message}`);
      }
    }
  },
  info(...msg) {
    console.info(`${con.title} %cINF`, con.color, '', 'color: rgb(0, 186, 124);', ...msg);
  },
  log(...msg) {
    console.log(`${con.title} %cLOG`, con.color, '', 'color: rgb(219, 160, 73);', ...msg);
  }
};
const { err, info } = con;
// #endregion
/**
 * @type { import("../typings/types.d.ts").config }
 */
let cfg;
/**
 * @type {URL | undefined}
 */
let url;
try {
  // for some reason `window.location.href` isn't always the same as `location.href`
  url = new URL(window.location.href ?? BLANK_PAGE);
} catch {
  /* empty */
}
//#region Placeholders
const BLANK_FN = function () {};
const BLANK_ASYNC_FN = async function () {};
const BLANK_PAGE = 'about:blank';
//#endregion
/**
 * @template {string} S
 * @param {S} hn
 */
const normalizedHostname = (hn) => hn.replace(/^www\./, '');
/**
 * @template {string} S
 * @param {S} txt
 */
const formatURL = (txt) =>
  txt
    .split('.')
    .splice(-2)
    .join('.')
    .replace(/\/|https:/g, '');
/**
 * @template {string} S
 * @param {S} str
 */
const getHostname = (str) => formatURL(normalizedHostname(str));
// #region Validators
/**
 * @type { import("../typings/types.d.ts").objToStr }
 */
const objToStr = (obj) => Object.prototype.toString.call(obj).match(/\[object (.*)\]/)[1];
/**
 * @type { import("../typings/types.d.ts").isRegExp }
 */
const isRegExp = (obj) => /RegExp/.test(objToStr(obj));
/**
 * @type { import("../typings/types.d.ts").isElem }
 */
const isElem = (obj) => /Element/.test(objToStr(obj));
/**
 * @type { import("../typings/types.d.ts").isHTML }
 */
const isHTML = (obj) => /HTML/.test(objToStr(obj));
/**
 * @type { import("../typings/types.d.ts").isObj }
 */
const isObj = (obj) => /Object/.test(objToStr(obj));
/**
 * @type { import("../typings/types.d.ts").isFN }
 */
const isFN = (obj) => /Function/.test(objToStr(obj));
const isUserCSS = (str) => /\.user\.css$/.test(str);
const isUserJS = (str) => /\.user\.js$/.test(str);
/**
 * @type { import("../typings/types.d.ts").isNull }
 */
const isNull = (obj) => {
  return Object.is(obj, null) || Object.is(obj, undefined);
};
/**
 * @type { import("../typings/types.d.ts").isBlank }
 */
const isBlank = (obj) => {
  return (
    (typeof obj === 'string' && Object.is(obj.trim(), '')) ||
    ((obj instanceof Set || obj instanceof Map) && Object.is(obj.size, 0)) ||
    (Array.isArray(obj) && Object.is(obj.length, 0)) ||
    (isObj(obj) && Object.is(Object.keys(obj).length, 0))
  );
};
/**
 * @type { import("../typings/types.d.ts").isEmpty }
 */
const isEmpty = (obj) => {
  return isNull(obj) || isBlank(obj);
};
// #endregion
// #region Globals
/** @type { import("../typings/UserJS.d.ts").safeHandles } */
let _self;
{
  /**
   * https://github.com/zloirock/core-js/blob/master/packages/core-js/internals/global-this.js
   * @returns {typeof globalThis}
   */
  const globalWin = () => {
    const check = (it) => it && it.Math === Math && it;
    return (
      check(typeof globalThis == 'object' && globalThis) ||
      check(typeof window == 'object' && window) ||
      check(typeof self == 'object' && self)
    );
  };
  const g = globalWin();
  try {
    /** @type { import("../typings/UserJS.d.ts").safeHandles } */
    const safe = {
      XMLHttpRequest: g.XMLHttpRequest,
      CustomEvent: g.CustomEvent,
      createElement: g.document.createElement.bind(g.document),
      createElementNS: g.document.createElementNS.bind(g.document),
      createTextNode: g.document.createTextNode.bind(g.document),
      setTimeout: g.setTimeout,
      clearTimeout: g.clearTimeout,
      navigator: g.navigator,
      scheduler: {
        postTask(callback, options) {
          if ('scheduler' in g && 'postTask' in g.scheduler) {
            return g.scheduler.postTask(callback, options);
          }
          options = Object.assign({}, options);
          if (options.delay === undefined) options.delay = 0;
          options.delay = Number(options.delay);
          if (options.delay < 0) {
            return Promise.reject(new TypeError('"delay" must be a positive number.'));
          }
          return new Promise((resolve) => {
            g.setTimeout(() => {
              resolve(callback());
            }, options.delay);
          });
        },
        yield() {
          if ('scheduler' in g && 'yield' in g.scheduler) {
            return g.scheduler.yield();
          }
          return new Promise((resolve) => {
            g.setTimeout(resolve, 0);
          });
        }
      },
      groupBy(items, keySelector) {
        if ('groupBy' in Object) {
          return Object.groupBy(items, keySelector);
        }
        /** [Object.groupBy polyfill](https://gist.github.com/gtrabanco/7c97bd41aa74af974fa935bfb5044b6e) */
        return items.reduce((acc = {}, ...args) => {
          const key = keySelector(...args);
          acc[key] ??= [];
          acc[key].push(args[0]);
          return acc;
        }, {});
      }
    };
    for (const [k, v] of Object.entries(safe)) {
      if (/scheduler|navigator/.test(k) || isFN(v)) continue;
      throw new Error(`Safe "${k}" returned "${v}"`, { cause: '_self' });
    }
    _self = safe;
  } catch (e) {
    err(e);
    _self = null;
  }
}
// #endregion
// #region Constants
/** Lets highlight me :) */
const authorID = 166061;
/**
 * Some UserJS I personally enjoy - `https://greasyfork.org/scripts/{id}`
 */
const goodUserJS = [
  33005,
  394820,
  438684,
  4870,
  394420,
  25068,
  483444,
  1682,
  22587,
  789,
  28497,
  386908,
  24204,
  404443,
  4336,
  368183,
  393396,
  473830,
  12179,
  423001,
  376510,
  23840,
  40525,
  6456,
  'https://openuserjs.org/install/Patabugen/Always_Remember_Me.user.js',
  'https://openuserjs.org/install/nokeya/Direct_links_out.user.js',
  'https://github.com/jijirae/y2monkey/raw/main/y2monkey.user.js',
  'https://github.com/jijirae/r2monkey/raw/main/r2monkey.user.js',
  'https://github.com/TagoDR/MangaOnlineViewer/raw/master/Manga_OnlineViewer.user.js',
  'https://github.com/jesus2099/konami-command/raw/master/INSTALL-USER-SCRIPT.user.js',
  'https://github.com/TagoDR/MangaOnlineViewer/raw/master/dist/Manga_OnlineViewer_Adult.user.js'
];
/** Remove UserJS from banned accounts */
const badUserJS = [478597];
/** Unsupport host for search engines */
const engineUnsupported = {
  greasyfork: ['pornhub.com'],
  sleazyfork: ['pornhub.com'],
  openuserjs: [],
  github: []
};
const isMobile = (() => {
  if (userjs.isMobile !== undefined) {
    return userjs.isMobile;
  }
  try {
    const { navigator } = _self;
    if (navigator) {
      const { userAgent = '', userAgentData = {} } = navigator;
      const { platform = '', mobile = false } = Object(userAgentData);
      userjs.isMobile =
        /Mobile|Tablet/.test(String(userAgent)) ||
        Boolean(mobile) ||
        /Android|Apple/.test(String(platform));
    } else {
      userjs.isMobile = false;
    }
  } catch (ex) {
    userjs.isMobile = false;
    ex.cause = 'getUAData';
    err(ex);
  }
  return userjs.isMobile;
})();
const isGM = typeof GM !== 'undefined' || typeof GM_xmlhttpRequest !== 'undefined';
const builtinList = {
  local: /localhost|router|gov|(\d+\.){3}\d+/,
  finance:
    /school|pay|bank|money|cart|checkout|authorize|bill|wallet|venmo|zalo|skrill|bluesnap|coin|crypto|currancy|insurance|finance/,
  social: /login|join|signin|signup|sign-up|password|reset|password_reset/,
  unsupported: {
    host: 'fakku.net',
    pathname: '/hentai/.+/read/page/.+'
  }
};
// #endregion
// #region DEFAULT_CONFIG
/**
 * @type { import("../typings/types.d.ts").config }
 */
const DEFAULT_CONFIG = {
  autofetch: false,
  autoinject: true,
  autoSort: 'daily_installs',
  clearTabCache: true,
  cache: true,
  autoexpand: false,
  filterlang: false,
  sleazyredirect: false,
  time: 10000,
  blacklist: ['userjs-local', 'userjs-finance', 'userjs-social', 'userjs-unsupported'],
  preview: {
    code: false,
    metadata: false
  },
  engines: [
    {
      enabled: true,
      name: 'greasyfork',
      query: encodeURIComponent('https://greasyfork.org/scripts/by-site/{host}.json?language=all')
    },
    {
      enabled: false,
      name: 'sleazyfork',
      query: encodeURIComponent('https://sleazyfork.org/scripts/by-site/{host}.json?language=all')
    },
    {
      enabled: false,
      name: 'openuserjs',
      query: encodeURIComponent('https://openuserjs.org/?q={host}')
    },
    {
      enabled: false,
      name: 'github',
      token: '',
      query: encodeURIComponent(
        'https://api.github.com/search/repositories?q=topic:{domain}+topic:userscript'
      )
    }
  ],
  theme: {
    'even-row': '',
    'odd-row': '',
    'even-err': '',
    'odd-err': '',
    'background-color': '',
    'gf-color': '',
    'sf-color': '',
    'border-b-color': '',
    'gf-btn-color': '',
    'sf-btn-color': '',
    'sf-txt-color': '',
    'txt-color': '',
    'chck-color': '',
    'chck-gf': '',
    'chck-git': '',
    'chck-open': '',
    placeholder: '',
    'position-top': '',
    'position-bottom': '',
    'position-left': '',
    'position-right': '',
    'font-family': ''
  },
  recommend: {
    author: true,
    others: true
  },
  filters: {
    ASCII: {
      enabled: false,
      name: 'Non-ASCII',
      regExp: '[^\\x00-\\x7F\\s]+'
    },
    Latin: {
      enabled: false,
      name: 'Non-Latin',
      regExp: '[^\\u0000-\\u024F\\u2000-\\u214F\\s]+'
    },
    Games: {
      enabled: false,
      name: 'Games',
      flag: 'iu',
      regExp:
        'Aimbot|AntiGame|Agar|agar\\.io|alis\\.io|angel\\.io|ExtencionRipXChetoMalo|AposBot|DFxLite|ZTx-Lite|AposFeedingBot|AposLoader|Balz|Blah Blah|Orc Clan Script|Astro\\s*Empires|^\\s*Attack|^\\s*Battle|BiteFight|Blood\\s*Wars|Bloble|Bonk|Bots|Bots4|Brawler|\\bBvS\\b|Business\\s*Tycoon|Castle\\s*Age|City\\s*Ville|chopcoin\\.io|Comunio|Conquer\\s*Club|CosmoPulse|cursors\\.io|Dark\\s*Orbit|Dead\\s*Frontier|Diep\\.io|\\bDOA\\b|doblons\\.io|DotD|Dossergame|Dragons\\s*of\\s*Atlantis|driftin\\.io|Dugout|\\bDS[a-z]+\\n|elites\\.io|Empire\\s*Board|eRep(ublik)?|Epicmafia|Epic.*War|ExoPlanet|Falcon Tools|Feuerwache|Farming|FarmVille|Fightinfo|Frontier\\s*Ville|Ghost\\s*Trapper|Gladiatus|Goalline|Gondal|gota\\.io|Grepolis|Hobopolis|\\bhwm(\\b|_)|Ikariam|\\bIT2\\b|Jellyneo|Kapi\\s*Hospital|Kings\\s*Age|Kingdoms?\\s*of|knastv(o|oe)gel|Knight\\s*Fight|\\b(Power)?KoC(Atta?ck)?\\b|\\bKOL\\b|Kongregate|Krunker|Last\\s*Emperor|Legends?\\s*of|Light\\s*Rising|lite\\.ext\\.io|Lockerz|\\bLoU\\b|Mafia\\s*(Wars|Mofo)|Menelgame|Mob\\s*Wars|Mouse\\s*Hunt|Molehill\\s*Empire|MooMoo|MyFreeFarm|narwhale\\.io|Neopets|NeoQuest|Nemexia|\\bOGame\\b|Ogar(io)?|Pardus|Pennergame|Pigskin\\s*Empire|PlayerScripts|pokeradar\\.io|Popmundo|Po?we?r\\s*(Bot|Tools)|PsicoTSI|Ravenwood|Schulterglatze|Skribbl|slither\\.io|slitherplus\\.io|slitheriogameplay|SpaceWars|splix\\.io|Survivio|\\bSW_[a-z]+\\n|\\bSnP\\b|The\\s*Crims|The\\s*West|torto\\.io|Travian|Treasure\\s*Isl(and|e)|Tribal\\s*Wars|TW.?PRO|Vampire\\s*Wars|vertix\\.io|War\\s*of\\s*Ninja|World\\s*of\\s*Tanks|West\\s*Wars|wings\\.io|\\bWoD\\b|World\\s*of\\s*Dungeons|wtf\\s*battles|Wurzelimperium|Yohoho|Zombs'
    },
    SocialNetworks: {
      enabled: false,
      name: 'Social Networks',
      flag: 'iu',
      regExp:
        'Face\\s*book|Google(\\+| Plus)|\\bHabbo|Kaskus|\\bLepra|Leprosorium|MySpace|meinVZ|odnoklassniki|Одноклассники|Orkut|sch(ue|ü)ler(VZ|\\.cc)?|studiVZ|Unfriend|Valenth|VK|vkontakte|ВКонтакте|Qzone|Twitter|TweetDeck'
    },
    Clutter: {
      enabled: false,
      name: 'Clutter',
      flag: 'iu',
      regExp:
        "^\\s*(.{1,3})\\1+\\n|^\\s*(.+?)\\n+\\2\\n*$|^\\s*.{1,5}\\n|do\\s*n('|o)?t (install|download)|nicht installieren|(just )?(\\ban? |\\b)test(ing|s|\\d|\\b)|^\\s*.{0,4}test.{0,4}\\n|\\ntest(ing)?\\s*|^\\s*(\\{@|Smolka|Hacks)|\\[\\d{4,5}\\]|free\\s*download|theme|(night|dark) ?(mode)?"
    }
  }
};
// #endregion
// #region i18n
const Language = class {
  static i18nMap = new Map(Object.entries(translations));
  /**
   * @param {string | Date | number} str
   */
  static toDate(str = '') {
    const {
      navigator: { language }
    } = _self;
    return new Intl.DateTimeFormat(language).format(typeof str === 'string' ? new Date(str) : str);
  }
  /**
   * @param {number | bigint} number
   */
  static toNumber(number) {
    const {
      navigator: { language }
    } = _self;
    return new Intl.NumberFormat(language).format(number);
  }
  /**
   * @type { import("../typings/UserJS.d.ts").i18n$ }
   */
  static i18n$(key) {
    try {
      return Language.i18nMap.get(Language.current)?.[key] ?? 'Invalid Key';
    } catch (e) {
      err(e);
      return 'error';
    }
  }
  static get current() {
    const {
      navigator: { language }
    } = _self;
    const [current = 'en'] = language.split('-');
    return current;
  }
};
const { i18n$ } = Language;
// #endregion
// #region Utilities
const union = (...arr) => [...new Set(arr.flat())];
/**
 * @param {string} str
 */
const decode = (str) => {
  try {
    if (decodeURI(str) !== decodeURIComponent(str)) {
      return decode(decodeURIComponent(str));
    }
  } catch (ex) {
    err(ex);
  }
  return str;
};
/**
 * @type { import("../typings/types.d.ts").normalizeTarget }
 */
const normalizeTarget = (target, toQuery = true, root) => {
  if (Object.is(target, null) || Object.is(target, undefined)) {
    return [];
  }
  if (Array.isArray(target)) {
    return target;
  }
  if (typeof target === 'string') {
    return toQuery ? Array.from((root || document).querySelectorAll(target)) : Array.of(target);
  }
  if (/object HTML/.test(Object.prototype.toString.call(target))) {
    return Array.of(target);
  }
  return Array.from(target);
};
/**
 * @type { import("../typings/types.d.ts").qs }
 */
const qs = (selector, root) => {
  try {
    return (root || document).querySelector(selector);
  } catch (ex) {
    err(ex);
  }
  return null;
};
/**
 * @type { import("../typings/types.d.ts").qsA }
 */
const qsA = (selectors, root) => {
  try {
    return (root || document).querySelectorAll(selectors);
  } catch (ex) {
    err(ex);
  }
  return [];
};
/**
 * @type { import("../typings/types.d.ts").ael }
 */
const ael = (el, type, listener, options = {}) => {
  for (const elem of normalizeTarget(el).filter(isHTML)) {
    if (isMobile && type === 'click') {
      elem.addEventListener('touchstart', listener, options);
      continue;
    }
    elem.addEventListener(type, listener, options);
  }
};
/**
 * @type { import("../typings/types.d.ts").formAttrs }
 */
const formAttrs = (elem, attr = {}) => {
  if (!elem) return elem;
  for (const [key, value] of Object.entries(attr)) {
    if (/^_mujs/i.test(key)) {
      elem[key] = value;
    } else if (typeof value === 'object') {
      formAttrs(elem[key], value);
    } else if (isFN(value)) {
      if (/^on/.test(key)) {
        elem[key] = value;
        continue;
      }
      ael(elem, key, value);
    } else if (/^class/i.test(key)) {
      dom.cl.add(elem, value);
    } else {
      elem[key] = value;
    }
  }
  return elem;
};
/**
 * @type { import("../typings/types.d.ts").make }
 */
const make = (tagName, cname, attrs) => {
  let el;
  try {
    el = _self.createElement(tagName.toLowerCase());
    if ((typeof cname === 'string' || Array.isArray(cname)) && !isEmpty(cname))
      dom.cl.add(el, cname);
    if (typeof attrs === 'string' && !isEmpty(attrs)) el.textContent = attrs;
    formAttrs(el, (isObj(cname) && cname) || (isObj(attrs) && attrs) || {});
  } catch (ex) {
    if (ex instanceof DOMException) throw new Error(`${ex.name}: ${ex.message}`, { cause: 'make' });
    ex.cause = 'make';
    err(ex);
  }
  return el;
};
const $info = (() => {
  if (isGM) {
    if (isObj(GM.info)) {
      return GM.info;
    } else if (isObj(GM_info)) {
      return GM_info;
    }
  }
  return {
    script: {
      icon: '',
      name: 'Magic Userscript+',
      namespace: 'https://github.com/magicoflolis/Userscript-Plus',
      updateURL: 'https://github.com/magicoflolis/Userscript-Plus/raw/master/dist/magic-userjs.js',
      version: 'Bookmarklet',
      bugs: 'https://github.com/magicoflolis/Userscript-Plus/issues'
    }
  };
})();
// #endregion
/**
 * @type { import("../typings/types.d.ts").dom }
 */
const dom = {
  attr(target, attr, value = undefined) {
    for (const elem of normalizeTarget(target).filter(isHTML)) {
      if (value === undefined) {
        return elem.getAttribute(attr);
      }
      if (value === null) {
        elem.removeAttribute(attr);
      } else {
        elem.setAttribute(attr, value);
      }
    }
  },
  prop(target, prop, value = undefined) {
    for (const elem of normalizeTarget(target).filter(isHTML)) {
      if (value === undefined) {
        return elem[prop];
      }
      elem[prop] = value;
    }
  },
  text(target, text) {
    const targets = normalizeTarget(target).filter(isHTML);
    if (text === undefined) {
      return targets.length !== 0 ? targets[0].textContent : undefined;
    }
    for (const elem of targets) {
      elem.textContent = text;
    }
  },
  remove(target) {
    normalizeTarget(target)
      .filter(isHTML)
      .some((elem) => elem.remove());
  },
  cl: {
    add(target, token) {
      token = normalizeTarget((typeof token === 'string' && token.split(' ')) || token, false);
      return normalizeTarget(target)
        .filter(isHTML)
        .some((elem) => elem.classList.add(...token));
    },
    remove(target, token) {
      token = normalizeTarget(token, false);
      return normalizeTarget(target)
        .filter(isHTML)
        .some((elem) => elem.classList.remove(...token));
    },
    toggle(target, token, force) {
      let r;
      for (const elem of normalizeTarget(target).filter(isHTML)) {
        r = elem.classList.toggle(token, force);
      }
      return r;
    },
    has(target, token) {
      return normalizeTarget(target)
        .filter(isHTML)
        .some((elem) => elem.classList.contains(token));
    }
  }
};
//#region Icon SVGs
const iconSVG = {
  close: {
    viewBox: '0 0 384 512',
    html: '<path d="M342.6 150.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L192 210.7 86.6 105.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3L146.7 256 41.4 361.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L192 301.3 297.4 406.6c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L237.3 256 342.6 150.6z"/>'
  },
  code: {
    viewBox: '0 0 640 512',
    html: '<path d="M392.8 1.2c-17-4.9-34.7 5-39.6 22l-128 448c-4.9 17 5 34.7 22 39.6s34.7-5 39.6-22l128-448c4.9-17-5-34.7-22-39.6zm80.6 120.1c-12.5 12.5-12.5 32.8 0 45.3L562.7 256l-89.4 89.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0l112-112c12.5-12.5 12.5-32.8 0-45.3l-112-112c-12.5-12.5-32.8-12.5-45.3 0zm-306.7 0c-12.5-12.5-32.8-12.5-45.3 0l-112 112c-12.5 12.5-12.5 32.8 0 45.3l112 112c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L77.3 256l89.4-89.4c12.5-12.5 12.5-32.8 0-45.3z"/>'
  },
  collapse: {
    viewBox: '0 0 448 512',
    html: '<path d="M160 64c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 64-64 0c-17.7 0-32 14.3-32 32s14.3 32 32 32l96 0c17.7 0 32-14.3 32-32l0-96zM32 320c-17.7 0-32 14.3-32 32s14.3 32 32 32l64 0 0 64c0 17.7 14.3 32 32 32s32-14.3 32-32l0-96c0-17.7-14.3-32-32-32l-96 0zM352 64c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 96c0 17.7 14.3 32 32 32l96 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-64 0 0-64zM320 320c-17.7 0-32 14.3-32 32l0 96c0 17.7 14.3 32 32 32s32-14.3 32-32l0-64 64 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-96 0z"/>'
  },
  download: {
    viewBox: '0 0 384 512',
    html: '<path d="M64 0C28.7 0 0 28.7 0 64L0 448c0 35.3 28.7 64 64 64l256 0c35.3 0 64-28.7 64-64l0-288-128 0c-17.7 0-32-14.3-32-32L224 0 64 0zM256 0l0 128 128 0L256 0zM216 232l0 102.1 31-31c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-72 72c-9.4 9.4-24.6 9.4-33.9 0l-72-72c-9.4-9.4-9.4-24.6 0-33.9s24.6-9.4 33.9 0l31 31L168 232c0-13.3 10.7-24 24-24s24 10.7 24 24z"/>'
  },
  expand: {
    viewBox: '0 0 448 512',
    html: '<path d="M32 32C14.3 32 0 46.3 0 64l0 96c0 17.7 14.3 32 32 32s32-14.3 32-32l0-64 64 0c17.7 0 32-14.3 32-32s-14.3-32-32-32L32 32zM64 352c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 96c0 17.7 14.3 32 32 32l96 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-64 0 0-64zM320 32c-17.7 0-32 14.3-32 32s14.3 32 32 32l64 0 0 64c0 17.7 14.3 32 32 32s32-14.3 32-32l0-96c0-17.7-14.3-32-32-32l-96 0zM448 352c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 64-64 0c-17.7 0-32 14.3-32 32s14.3 32 32 32l96 0c17.7 0 32-14.3 32-32l0-96z"/>'
  },
  gear: {
    viewBox: '0 0 512 512',
    html: '<path d="M495.9 166.6c3.2 8.7 .5 18.4-6.4 24.6l-43.3 39.4c1.1 8.3 1.7 16.8 1.7 25.4s-.6 17.1-1.7 25.4l43.3 39.4c6.9 6.2 9.6 15.9 6.4 24.6c-4.4 11.9-9.7 23.3-15.8 34.3l-4.7 8.1c-6.6 11-14 21.4-22.1 31.2c-5.9 7.2-15.7 9.6-24.5 6.8l-55.7-17.7c-13.4 10.3-28.2 18.9-44 25.4l-12.5 57.1c-2 9.1-9 16.3-18.2 17.8c-13.8 2.3-28 3.5-42.5 3.5s-28.7-1.2-42.5-3.5c-9.2-1.5-16.2-8.7-18.2-17.8l-12.5-57.1c-15.8-6.5-30.6-15.1-44-25.4L83.1 425.9c-8.8 2.8-18.6 .3-24.5-6.8c-8.1-9.8-15.5-20.2-22.1-31.2l-4.7-8.1c-6.1-11-11.4-22.4-15.8-34.3c-3.2-8.7-.5-18.4 6.4-24.6l43.3-39.4C64.6 273.1 64 264.6 64 256s.6-17.1 1.7-25.4L22.4 191.2c-6.9-6.2-9.6-15.9-6.4-24.6c4.4-11.9 9.7-23.3 15.8-34.3l4.7-8.1c6.6-11 14-21.4 22.1-31.2c5.9-7.2 15.7-9.6 24.5-6.8l55.7 17.7c13.4-10.3 28.2-18.9 44-25.4l12.5-57.1c2-9.1 9-16.3 18.2-17.8C227.3 1.2 241.5 0 256 0s28.7 1.2 42.5 3.5c9.2 1.5 16.2 8.7 18.2 17.8l12.5 57.1c15.8 6.5 30.6 15.1 44 25.4l55.7-17.7c8.8-2.8 18.6-.3 24.5 6.8c8.1 9.8 15.5 20.2 22.1 31.2l4.7 8.1c6.1 11 11.4 22.4 15.8 34.3zM256 336a80 80 0 1 0 0-160 80 80 0 1 0 0 160z"/>'
  },
  github: {
    viewBox: '0 0 496 512',
    html: '<path d="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3 .3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5 .3-6.2 2.3zm44.2-1.7c-2.9 .7-4.9 2.6-4.6 4.9 .3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3 .7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3 .3 2.9 2.3 3.9 1.6 1 3.6 .7 4.3-.7 .7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3 .7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3 .7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/>'
  },
  globe: {
    viewBox: '0 0 512 512',
    html: '<path d="M352 256c0 22.2-1.2 43.6-3.3 64l-185.3 0c-2.2-20.4-3.3-41.8-3.3-64s1.2-43.6 3.3-64l185.3 0c2.2 20.4 3.3 41.8 3.3 64zm28.8-64l123.1 0c5.3 20.5 8.1 41.9 8.1 64s-2.8 43.5-8.1 64l-123.1 0c2.1-20.6 3.2-42 3.2-64s-1.1-43.4-3.2-64zm112.6-32l-116.7 0c-10-63.9-29.8-117.4-55.3-151.6c78.3 20.7 142 77.5 171.9 151.6zm-149.1 0l-176.6 0c6.1-36.4 15.5-68.6 27-94.7c10.5-23.6 22.2-40.7 33.5-51.5C239.4 3.2 248.7 0 256 0s16.6 3.2 27.8 13.8c11.3 10.8 23 27.9 33.5 51.5c11.6 26 20.9 58.2 27 94.7zm-209 0L18.6 160C48.6 85.9 112.2 29.1 190.6 8.4C165.1 42.6 145.3 96.1 135.3 160zM8.1 192l123.1 0c-2.1 20.6-3.2 42-3.2 64s1.1 43.4 3.2 64L8.1 320C2.8 299.5 0 278.1 0 256s2.8-43.5 8.1-64zM194.7 446.6c-11.6-26-20.9-58.2-27-94.6l176.6 0c-6.1 36.4-15.5 68.6-27 94.6c-10.5 23.6-22.2 40.7-33.5 51.5C272.6 508.8 263.3 512 256 512s-16.6-3.2-27.8-13.8c-11.3-10.8-23-27.9-33.5-51.5zM135.3 352c10 63.9 29.8 117.4 55.3 151.6C112.2 482.9 48.6 426.1 18.6 352l116.7 0zm358.1 0c-30 74.1-93.6 130.9-171.9 151.6c25.5-34.2 45.2-87.7 55.3-151.6l116.7 0z"/>'
  },
  info: {
    viewBox: '0 0 512 512',
    html: '<path d="M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM216 336l24 0 0-64-24 0c-13.3 0-24-10.7-24-24s10.7-24 24-24l48 0c13.3 0 24 10.7 24 24l0 88 8 0c13.3 0 24 10.7 24 24s-10.7 24-24 24l-80 0c-13.3 0-24-10.7-24-24s10.7-24 24-24zm40-208a32 32 0 1 1 0 64 32 32 0 1 1 0-64z"/>'
  },
  install: {
    viewBox: '0 0 512 512',
    html: '<path d="M288 32c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 242.7-73.4-73.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l128 128c12.5 12.5 32.8 12.5 45.3 0l128-128c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L288 274.7 288 32zM64 352c-35.3 0-64 28.7-64 64l0 32c0 35.3 28.7 64 64 64l384 0c35.3 0 64-28.7 64-64l0-32c0-35.3-28.7-64-64-64l-101.5 0-45.3 45.3c-25 25-65.5 25-90.5 0L165.5 352 64 352zm368 56a24 24 0 1 1 0 48 24 24 0 1 1 0-48z"/>'
  },
  issue: {
    viewBox: '0 0 512 512',
    html: '<path d="M256 0c53 0 96 43 96 96l0 3.6c0 15.7-12.7 28.4-28.4 28.4l-135.1 0c-15.7 0-28.4-12.7-28.4-28.4l0-3.6c0-53 43-96 96-96zM41.4 105.4c12.5-12.5 32.8-12.5 45.3 0l64 64c.7 .7 1.3 1.4 1.9 2.1c14.2-7.3 30.4-11.4 47.5-11.4l112 0c17.1 0 33.2 4.1 47.5 11.4c.6-.7 1.2-1.4 1.9-2.1l64-64c12.5-12.5 32.8-12.5 45.3 0s12.5 32.8 0 45.3l-64 64c-.7 .7-1.4 1.3-2.1 1.9c6.2 12 10.1 25.3 11.1 39.5l64.3 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-64 0c0 24.6-5.5 47.8-15.4 68.6c2.2 1.3 4.2 2.9 6 4.8l64 64c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0l-63.1-63.1c-24.5 21.8-55.8 36.2-90.3 39.6L272 240c0-8.8-7.2-16-16-16s-16 7.2-16 16l0 239.2c-34.5-3.4-65.8-17.8-90.3-39.6L86.6 502.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l64-64c1.9-1.9 3.9-3.4 6-4.8C101.5 367.8 96 344.6 96 320l-64 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l64.3 0c1.1-14.1 5-27.5 11.1-39.5c-.7-.6-1.4-1.2-2.1-1.9l-64-64c-12.5-12.5-12.5-32.8 0-45.3z"/>'
  },
  minus: {
    viewBox: '0 0 448 512',
    html: '<path d="M432 256c0 17.7-14.3 32-32 32L48 288c-17.7 0-32-14.3-32-32s14.3-32 32-32l352 0c17.7 0 32 14.3 32 32z"/>'
  },
  nav: {
    viewBox: '0 0 448 512',
    html: '<path d="M0 96C0 78.3 14.3 64 32 64l384 0c17.7 0 32 14.3 32 32s-14.3 32-32 32L32 128C14.3 128 0 113.7 0 96zM0 256c0-17.7 14.3-32 32-32l384 0c17.7 0 32 14.3 32 32s-14.3 32-32 32L32 288c-17.7 0-32-14.3-32-32zM448 416c0 17.7-14.3 32-32 32L32 448c-17.7 0-32-14.3-32-32s14.3-32 32-32l384 0c17.7 0 32 14.3 32 32z"/>'
  },
  pager: {
    viewBox: '0 0 512 512',
    html: '<path d="M0 128C0 92.7 28.7 64 64 64l384 0c35.3 0 64 28.7 64 64l0 256c0 35.3-28.7 64-64 64L64 448c-35.3 0-64-28.7-64-64L0 128zm64 32l0 64c0 17.7 14.3 32 32 32l320 0c17.7 0 32-14.3 32-32l0-64c0-17.7-14.3-32-32-32L96 128c-17.7 0-32 14.3-32 32zM80 320c-13.3 0-24 10.7-24 24s10.7 24 24 24l56 0c13.3 0 24-10.7 24-24s-10.7-24-24-24l-56 0zm136 0c-13.3 0-24 10.7-24 24s10.7 24 24 24l48 0c13.3 0 24-10.7 24-24s-10.7-24-24-24l-48 0z"/>'
  },
  verified: {
    viewBox: '0 0 56 56',
    fill: 'currentColor',
    stroke: 'currentColor',
    html: '<g stroke-width="0"/><g stroke-linecap="round" stroke-linejoin="round"/><g><path d="M 23.6641 52.3985 C 26.6407 55.375 29.3594 55.3516 32.3126 52.3985 L 35.9219 48.8125 C 36.2969 48.4610 36.6250 48.3203 37.1172 48.3203 L 42.1797 48.3203 C 46.3749 48.3203 48.3204 46.3985 48.3204 42.1797 L 48.3204 37.1172 C 48.3204 36.625 48.4610 36.2969 48.8124 35.9219 L 52.3749 32.3125 C 55.3749 29.3594 55.3514 26.6407 52.3749 23.6641 L 48.8124 20.0547 C 48.4610 19.7031 48.3204 19.3516 48.3204 18.8829 L 48.3204 13.7969 C 48.3204 9.625 46.3985 7.6563 42.1797 7.6563 L 37.1172 7.6563 C 36.6250 7.6563 36.2969 7.5391 35.9219 7.1875 L 32.3126 3.6016 C 29.3594 .6250 26.6407 .6485 23.6641 3.6016 L 20.0547 7.1875 C 19.7032 7.5391 19.3516 7.6563 18.8828 7.6563 L 13.7969 7.6563 C 9.6016 7.6563 7.6563 9.5782 7.6563 13.7969 L 7.6563 18.8829 C 7.6563 19.3516 7.5391 19.7031 7.1876 20.0547 L 3.6016 23.6641 C .6251 26.6407 .6485 29.3594 3.6016 32.3125 L 7.1876 35.9219 C 7.5391 36.2969 7.6563 36.625 7.6563 37.1172 L 7.6563 42.1797 C 7.6563 46.3750 9.6016 48.3203 13.7969 48.3203 L 18.8828 48.3203 C 19.3516 48.3203 19.7032 48.4610 20.0547 48.8125 Z M 26.2891 49.7734 L 21.8828 45.3438 C 21.3672 44.8047 20.8282 44.5938 20.1016 44.5938 L 13.7969 44.5938 C 11.7110 44.5938 11.3828 44.2656 11.3828 42.1797 L 11.3828 35.875 C 11.3828 35.1719 11.1719 34.6329 10.6563 34.1172 L 6.2266 29.7109 C 4.7501 28.2109 4.7501 27.7891 6.2266 26.2891 L 10.6563 21.8829 C 11.1719 21.3672 11.3828 20.8282 11.3828 20.1016 L 11.3828 13.7969 C 11.3828 11.6875 11.6876 11.3829 13.7969 11.3829 L 20.1016 11.3829 C 20.8282 11.3829 21.3672 11.1953 21.8828 10.6563 L 26.2891 6.2266 C 27.7891 4.7500 28.2110 4.7500 29.7110 6.2266 L 34.1172 10.6563 C 34.6328 11.1953 35.1719 11.3829 35.8750 11.3829 L 42.1797 11.3829 C 44.2657 11.3829 44.5938 11.7109 44.5938 13.7969 L 44.5938 20.1016 C 44.5938 20.8282 44.8282 21.3672 45.3439 21.8829 L 49.7733 26.2891 C 51.2498 27.7891 51.2498 28.2109 49.7733 29.7109 L 45.3439 34.1172 C 44.8282 34.6329 44.5938 35.1719 44.5938 35.875 L 44.5938 42.1797 C 44.5938 44.2656 44.2657 44.5938 42.1797 44.5938 L 35.8750 44.5938 C 35.1719 44.5938 34.6328 44.8047 34.1172 45.3438 L 29.7110 49.7734 C 28.2110 51.2500 27.7891 51.2500 26.2891 49.7734 Z M 24.3438 39.2266 C 25.0235 39.2266 25.5391 38.9453 25.8907 38.5234 L 38.8985 20.3360 C 39.1563 19.9609 39.2969 19.5391 39.2969 19.1407 C 39.2969 18.1094 38.5001 17.2891 37.4219 17.2891 C 36.6485 17.2891 36.2266 17.5469 35.7579 18.2266 L 24.2735 34.3985 L 18.3438 27.8594 C 17.9454 27.4141 17.5001 27.2266 16.9141 27.2266 C 15.7657 27.2266 14.9454 28.0000 14.9454 29.0782 C 14.9454 29.5469 15.1094 29.9922 15.4376 30.3203 L 22.8907 38.6172 C 23.2423 38.9922 23.6876 39.2266 24.3438 39.2266 Z"/></g>'
  },
  refresh: {
    viewBox: '0 0 512 512',
    fill: 'currentColor',
    html: '<path d="M463.5 224l8.5 0c13.3 0 24-10.7 24-24l0-128c0-9.7-5.8-18.5-14.8-22.2s-19.3-1.7-26.2 5.2L413.4 96.6c-87.6-86.5-228.7-86.2-315.8 1c-87.5 87.5-87.5 229.3 0 316.8s229.3 87.5 316.8 0c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0c-62.5 62.5-163.8 62.5-226.3 0s-62.5-163.8 0-226.3c62.2-62.2 162.7-62.5 225.3-1L327 183c-6.9 6.9-8.9 17.2-5.2 26.2s12.5 14.8 22.2 14.8l119.5 0z"/>'
  },
  load(type, container) {
    const svgElem = _self.createElementNS('http://www.w3.org/2000/svg', 'svg');
    for (const [k, v] of Object.entries(iconSVG[type])) {
      if (k === 'html') continue;
      svgElem.setAttributeNS(null, k, v);
    }
    try {
      if (typeof iconSVG[type].html === 'string') {
        svgElem.innerHTML = iconSVG[type].html;
        svgElem.setAttribute('id', `mujs_${type ?? 'Unknown'}`);
      }
    } catch {
      /* empty */
    }
    if (isElem(container)) {
      container.appendChild(svgElem);
      return svgElem;
    } else if (isObj(container)) {
      formAttrs(svgElem, container);
    }
    return svgElem.outerHTML;
  }
};
//#endregion
/**
 * @type { import("../typings/UserJS.d.ts").StorageSystem }
 */
const StorageSystem = {
  prefix: 'MUJS',
  events: new Set(),
  getItem(key) {
    return window.localStorage.getItem(key);
  },
  has(key) {
    return !this.getItem(key);
  },
  setItem(key, value) {
    window.localStorage.setItem(key, value);
  },
  remove(key) {
    window.localStorage.removeItem(key);
  },
  async setValue(key, v) {
    if (!v) {
      return;
    }
    v = typeof v === 'string' ? v : JSON.stringify(v);
    if (isGM) {
      if (isFN(GM.setValue)) {
        await GM.setValue(key, v);
      } else if (isFN(GM_setValue)) {
        GM_setValue(key, v);
      }
    } else {
      this.setItem(`${this.prefix}-${key}`, v);
    }
  },
  async getValue(key, def = {}) {
    try {
      if (isGM) {
        let GMType;
        if (isFN(GM.getValue)) {
          GMType = await GM.getValue(key, JSON.stringify(def));
        } else if (isFN(GM_getValue)) {
          GMType = GM_getValue(key, JSON.stringify(def));
        }
        if (!isNull(GMType)) {
          return JSON.parse(GMType);
        }
      }
      return this.has(`${this.prefix}-${key}`)
        ? JSON.parse(this.getItem(`${this.prefix}-${key}`))
        : def;
    } catch (ex) {
      ex.cause = 'getValue';
      err(ex);
      return def;
    }
  }
};
const Command = {
  cmds: new Set(),
  register(text, command) {
    if (!isGM) {
      return;
    }

    if (isFN(command)) {
      if (this.cmds.has(command)) {
        return;
      }
      this.cmds.add(command);
    }

    if (isFN(GM.registerMenuCommand)) {
      GM.registerMenuCommand(text, command);
    } else if (isFN(GM_registerMenuCommand)) {
      GM_registerMenuCommand(text, command);
    }
  }
};
/**
 * @type { import("../typings/UserJS.d.ts").Network }
 */
const Network = {
  async req(url, method = 'GET', responseType = 'json', data, useFetch = false) {
    if (isEmpty(url)) {
      throw new Error('"url" parameter is empty');
    }
    data = Object.assign({}, data);
    method = this.bscStr(method, false);
    responseType = this.bscStr(responseType, true);
    const params = {
      method,
      ...data
    };
    if (isGM && !useFetch) {
      if (params.credentials) {
        Object.assign(params, {
          anonymous: false
        });
        if (Object.is(params.credentials, 'omit')) {
          Object.assign(params, {
            anonymous: true
          });
        }
        delete params.credentials;
      }
    } else if (params.onprogress) {
      delete params.onprogress;
    }
    return new Promise((resolve, reject) => {
      if (isGM && !useFetch) {
        Network.xmlRequest({
          url,
          responseType,
          ...params,
          onerror: (r_1) => {
            reject(new Error(`${r_1.status} ${url}`));
          },
          onload: (r_1) => {
            if (r_1.status !== 200) reject(new Error(`${r_1.status} ${url}`));
            if (responseType.match(/basic/)) resolve(r_1);
            resolve(r_1.response);
          }
        });
      } else {
        fetch(url, params)
          .then((response_1) => {
            if (!response_1.ok) reject(response_1);
            const check = (str_2 = 'text') => {
              return isFN(response_1[str_2]) ? response_1[str_2]() : response_1;
            };
            if (responseType.match(/buffer/)) {
              resolve(check('arrayBuffer'));
            } else if (responseType.match(/json/)) {
              resolve(check('json'));
            } else if (responseType.match(/text/)) {
              resolve(check('text'));
            } else if (responseType.match(/blob/)) {
              resolve(check('blob'));
            } else if (responseType.match(/formdata/)) {
              resolve(check('formData'));
            } else if (responseType.match(/clone/)) {
              resolve(check('clone'));
            } else if (responseType.match(/document/)) {
              const respTxt = check('text');
              const domParser = new DOMParser();
              if (respTxt instanceof Promise) {
                respTxt.then((txt) => {
                  const doc = domParser.parseFromString(txt, 'text/html');
                  resolve(doc);
                });
              } else {
                const doc = domParser.parseFromString(respTxt, 'text/html');
                resolve(doc);
              }
            } else {
              resolve(response_1);
            }
          })
          .catch(reject);
      }
    });
  },
  format(bytes, decimals = 2) {
    if (Number.isNaN(bytes)) return `0 ${this.sizes[0]}`;
    const k = 1024;
    const dm = decimals < 0 ? 0 : decimals;
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${this.sizes[i]}`;
  },
  sizes: ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
  async xmlRequest(details) {
    if (isGM) {
      if (isFN(GM.xmlHttpRequest)) {
        return GM.xmlHttpRequest(details);
      } else if (isFN(GM_xmlhttpRequest)) {
        return GM_xmlhttpRequest(details);
      }
    }
    return await new Promise((resolve, reject) => {
      const req = new _self.XMLHttpRequest();
      let method = 'GET';
      let url = BLANK_PAGE;
      let body;
      for (const [key, value] of Object.entries(details)) {
        if (key === 'onload') {
          req.addEventListener('load', () => {
            if (isFN(value)) {
              value(req);
            }
            resolve(req);
          });
        } else if (key === 'onerror') {
          req.addEventListener('error', (evt) => {
            if (isFN(value)) {
              value(evt);
            }
            reject(evt);
          });
        } else if (key === 'onabort') {
          req.addEventListener('abort', (evt) => {
            if (isFN(value)) {
              value(evt);
            }
            reject(evt);
          });
        } else if (key === 'onprogress') {
          req.addEventListener('progress', value);
        } else if (key === 'responseType') {
          if (value === 'buffer') {
            req.responseType = 'arraybuffer';
          } else {
            req.responseType = value;
          }
        } else if (key === 'method') {
          method = value;
        } else if (key === 'url') {
          url = value;
        } else if (key === 'body') {
          body = value;
        }
      }
      req.open(method, url);

      if (isEmpty(req.responseType)) {
        req.responseType = 'text';
      }

      if (body) {
        req.send(body);
      } else {
        req.send();
      }
    });
  },
  bscStr(str = '', lowerCase = true) {
    const txt = str[lowerCase ? 'toLowerCase' : 'toUpperCase']();
    return txt.replaceAll(/\W/g, '');
  }
};
const Counter = {
  cnt: {
    total: {
      count: 0
    }
  },
  set(engine) {
    if (!this.cnt[engine.name]) {
      const counter = make('count-frame', engine.enabled ? '' : 'hidden', {
        dataset: {
          counter: engine.name
        },
        title: decode(engine.query ?? engine.url),
        textContent: '0'
      });
      this.cnt[engine.name] = {
        root: counter,
        count: 0
      };
      return counter;
    }
    return this.cnt[engine.name].root;
  },
  update(count, engine) {
    this.cnt[engine.name].count += count;
    this.cnt.total.count += count;
    this.updateAll();
  },
  updateAll() {
    for (const v of Object.values(this.cnt)) dom.text(v.root, v.count);
  },
  reset() {
    for (const [k, v] of Object.entries(this.cnt)) {
      dom.text(v.root, 0);
      v.count = 0;
      const engine = cfg.engines.find((engine) => k === engine.name);
      if (engine) {
        dom.cl[engine.enabled ? 'remove' : 'add'](v.root, 'hidden');
      }
    }
  }
};
// #region Container
/**
 * @type { typeof import("../typings/UserJS.d.ts").Container }
 */
const Container = class {
  static prompts = [];
  webpage;
  host;
  injected;
  shadowRoot;
  shadowSupport;
  frame;
  userjsCache;
  root;
  unsaved;
  isBlacklisted;
  rebuild;
  opacityMin;
  opacityMax;
  constructor() {
    this.remove = this.remove.bind(this);
    this.refresh = this.refresh.bind(this);
    this.showError = this.showError.bind(this);
    this.toElem = this.toElem.bind(this);

    this.webpage = url;
    this.host = getHostname(url?.hostname ?? BLANK_PAGE);
    this.injected = false;
    this.shadowRoot = undefined;
    this.shadowSupport = isFN(make('main-userjs').attachShadow);

    if (!this.shadowSupport)
      throw new Error('Failed to initialize: "attachShadow not supported"', { cause: 'Container' });
    this.frame = make('main-userjs', {
      style: 'visibility: visible;',
      dataset: {
        insertedBy: $info.script.name,
        role: 'primary-container'
      }
    });
    this.shadowRoot = this.frame.attachShadow({ mode: 'closed' });

    this.userjsCache = new Map();
    this.root = make('mujs-root');
    this.unsaved = false;
    this.isBlacklisted = false;
    this.rebuild = false;
    this.opacityMin = '0.15';
    this.opacityMax = '1';
    this.elementsReady = this.init();

    const Timeout = class {
      constructor() {
        /**
         * @type {number[]}
         */
        this.ids = [];
      }
      /**
       * @template R
       * @param {number} delay
       * @param {R} [reason]
       */
      set(delay, reason) {
        return new Promise((resolve, reject) => {
          const id = _self.setTimeout(() => {
            Object.is(reason, null) || Object.is(reason, undefined) ? resolve() : reject(reason);
            this.clear(id);
          }, delay);
          this.ids.push(id);
        });
      }
      /**
       * @param {...number} ids
       */
      clear(...ids) {
        this.ids = this.ids.filter((id) => {
          if (ids.includes(id)) {
            _self.clearTimeout(id);
            return false;
          }
          return true;
        });
      }
    };
    this.timeouts = {
      frame: new Timeout(),
      mouse: new Timeout()
    };

    this.injFN = BLANK_FN;

    window.addEventListener('beforeunload', this.remove);
  }
  inject(callback, doc) {
    if (this.checkBlacklist(this.host)) {
      err(`Blacklisted "${this.host}"`);
      this.remove();
      return;
    }
    if (!this.shadowRoot || isNull(doc)) return;
    try {
      doc.documentElement.appendChild(this.frame);
      if (this.injected) {
        if (isFN(this.injFN.build)) {
          this.injFN.build();
        }
        return;
      }
      this.shadowRoot.append(this.root);
      if (isNull(this.loadCSS(main_css, 'primary-stylesheet')))
        throw new Error('Failed to initialize script!', { cause: 'loadCSS' });
      this.injected = true;
      this.initFn();
      if (isFN(callback) && this.elementsReady) this.injFN = callback.call(this, this.shadowRoot);
    } catch (ex) {
      err(ex);
      this.remove();
    }
  }
  initFn() {
    this.setTheme();

    Counter.cnt.total.root = this.mainbtn;
    if (this.countframe)
      for (const engine of cfg.engines) this.countframe.append(Counter.set(engine));
    const { refresh, urlBar, host, userjsCache, cfgpage, table } = this;

    class Tabs {
      /**
       * @param { HTMLElement } root
       */
      constructor(root) {
        /**
         * @type { Set<HTMLElement> }
         */
        this.pool = new Set();
        this.blank = BLANK_PAGE;
        this.protocal = 'mujs:';
        this.protoReg = new RegExp(`${this.protocal}(.+)`, 'i');
        this.el = {
          add: make('mujs-addtab', {
            textContent: '+',
            dataset: {
              command: 'new-tab'
            }
          }),
          head: make('mujs-tabs'),
          root
        };
        this.el.head.append(this.el.add);
        this.el.root.append(this.el.head);
        this.custom = BLANK_FN;
      }
      /**
       * @param {string} hostname
       */
      getTab(hostname) {
        return [...this.pool].find(({ dataset }) => hostname === dataset.host);
      }
      getActive() {
        return [...this.pool].find((tab) => tab.classList.contains('active'));
      }
      /**
       * @param {string} hostname
       */
      intFN(hostname) {
        const [, host] = this.protoReg.exec(hostname) ?? [];
        if (host === 'settings') {
          dom.cl.remove(cfgpage, 'hidden');
          dom.cl.add(table, 'hidden');
          urlBar.placeholder = 'Search settings';
        }
      }
      /**
       * @param {HTMLElement} tab
       * @param {boolean} [build]
       */
      active(tab, build = true) {
        if (!this.pool.has(tab)) this.pool.add(tab);
        dom.cl.add([table, cfgpage], 'hidden');
        dom.cl.remove([...this.pool], 'active');
        dom.cl.add(tab, 'active');
        if (!build) {
          dom.cl.remove(table, 'hidden');
          return;
        }
        const host = tab.dataset.host ?? this.blank;
        if (host === this.blank) {
          dom.cl.add(cfgpage, 'hidden');
          dom.cl.remove(table, 'hidden');
          refresh();
        } else if (host.startsWith(this.protocal)) {
          this.intFN(host);
        } else {
          dom.cl.add(cfgpage, 'hidden');
          dom.cl.remove(table, 'hidden');
          this.custom(host);
        }
      }
      /** @param { HTMLElement } tab */
      close(tab) {
        if (this.pool.has(tab)) this.pool.delete(tab);
        if (cfg.clearTabCache) {
          const { host } = tab.dataset;
          const arr = Array.from(userjsCache.values()).filter(({ _mujs }) => {
            return !isEmpty(_mujs) && _mujs.info.host === host;
          });
          for (const a of arr) {
            arr.splice(arr.indexOf(a), 1);
          }
        }
        if (tab.classList.contains('active')) refresh();
        const sibling = tab.nextElementSibling ?? tab.previousElementSibling;
        if (sibling) {
          if (sibling.dataset.command !== 'new-tab') {
            this.active(sibling);
          }
        }
        tab.remove();
      }
      /**
       * @param {string} [hostname]
       */
      create(hostname = undefined) {
        if (typeof hostname === 'string') {
          const createdTab = this.getTab(hostname);
          if (this.protoReg.test(hostname) && createdTab) {
            this.active(createdTab);
            return;
          }
        }
        const tab = make('mujs-tab', {
          dataset: {
            command: 'switch-tab'
          },
          style: `order: ${this.el.head.childElementCount};`
        });
        const tabClose = make('mu-js', {
          dataset: {
            command: 'close-tab'
          },
          title: i18n$('close'),
          textContent: 'X'
        });
        const tabHost = make('mujs-host');
        const [, host] = this.protoReg.exec(hostname) ?? [];
        tab.append(tabHost, tabClose);
        this.el.head.append(tab);
        this.active(tab, false);
        if (isNull(hostname)) {
          refresh();
          tab.dataset.host = this.blank;
          tabHost.title = i18n$('newTab');
          tabHost.textContent = i18n$('newTab');
        } else if (host) {
          tab.dataset.host = hostname || host;
          tabHost.title = host || tab.dataset.host;
          tabHost.textContent = tabHost.title;
          this.intFN(hostname);
        } else {
          tab.dataset.host = hostname || host;
          tabHost.title = hostname || host;
          tabHost.textContent = tabHost.title;
        }
        return tab;
      }
    }
    this.Tabs = new Tabs(this.toolbar);
    this.Tabs.create(host);

    const tabbody = this.tabbody;
    const getCellValue = (tr, idx) =>
      tr.children[idx].dataset.value || tr.children[idx].textContent;
    const comparer = (idx, asc) => (a, b) =>
      ((v1, v2) =>
        v1 !== '' && v2 !== '' && !isNaN(v1) && !isNaN(v2)
          ? v1 - v2
          : v1.toString().localeCompare(v2))(
        getCellValue(asc ? a : b, idx),
        getCellValue(asc ? b : a, idx)
      );
    for (const th of this.tabhead.rows[0].cells) {
      if (dom.text(th) === i18n$('install')) continue;
      dom.cl.add(th, 'mujs-pointer');
      ael(th, 'click', () => {
        /** [Stack Overflow Reference](https://stackoverflow.com/questions/14267781/sorting-html-table-with-javascript/53880407#53880407) */
        Array.from(tabbody.querySelectorAll('tr'))
          .sort(comparer(Array.from(th.parentNode.children).indexOf(th), (this.asc = !this.asc)))
          .forEach((tr) => tabbody.appendChild(tr));
      });
    }
  }
  init() {
    try {
      // #region Elements
      this.mainframe = make('mu-js', 'mainframe', {
        style: `opacity: ${this.opacityMin};`
      });
      this.countframe = make('mujs-column');
      this.mainbtn = make('count-frame', 'mainbtn', {
        textContent: '0'
      });
      this.urlBar = make('input', 'mujs-url-bar', {
        autocomplete: 'off',
        spellcheck: false,
        type: 'text',
        placeholder: i18n$('search_placeholder')
      });
      this.rateContainer = make('mujs-column', 'rate-container');
      this.footer = make('mujs-row', 'mujs-footer');
      this.tabbody = make('tbody');
      this.promptElem = make('mujs-row', 'mujs-prompt');
      this.toolbar = make('mujs-toolbar');
      this.table = make('table');
      this.tabhead = make('thead');
      this.header = make('mujs-header');
      this.tbody = make('mujs-body');
      this.cfgpage = make('mujs-row', 'mujs-cfg hidden', {
        _mujs: {
          base: [],
          sections: new Set()
        }
      });
      this.main = make('mujs-main', 'hidden');
      this.urlContainer = make('mujs-url');
      this.btnframe = make('mujs-column', 'btn-frame');
      this.btnHandles = make('mujs-column', 'btn-handles');
      this.btnHide = make('mujs-btn', 'hide-list', {
        title: i18n$('min'),
        innerHTML: iconSVG.load('minus'),
        dataset: {
          command: 'hide-list'
        }
      });
      this.btnfullscreen = make('mujs-btn', 'fullscreen', {
        title: i18n$('max'),
        innerHTML: iconSVG.load('expand'),
        dataset: {
          command: 'fullscreen'
        }
      });
      this.closebtn = make('mujs-btn', 'close', {
        title: i18n$('close'),
        innerHTML: iconSVG.load('close'),
        dataset: {
          command: 'close'
        }
      });
      this.btncfg = make('mujs-btn', 'settings hidden', {
        title: 'Settings',
        innerHTML: iconSVG.load('gear'),
        dataset: {
          command: 'settings'
        }
      });
      this.btnhome = make('mujs-btn', 'github hidden', {
        title: `GitHub (v${
          /\d+\.\d+\.\d+|Book/.test($info.script.version)
            ? $info.script.version
            : $info.script.version.slice(0, 5)
        })`,
        innerHTML: iconSVG.load('github'),
        dataset: {
          command: 'open-tab',
          webpage: $info.script.namespace
        }
      });
      this.btnissue = make('mujs-btn', 'issue hidden', {
        innerHTML: iconSVG.load('issue'),
        title: i18n$('issue'),
        dataset: {
          command: 'open-tab',
          webpage: $info.script.bugs ?? 'https://github.com/magicoflolis/Userscript-Plus/issues'
        }
      });
      this.btngreasy = make('mujs-btn', 'greasy hidden', {
        title: 'Greasy Fork',
        innerHTML: iconSVG.load('globe'),
        dataset: {
          command: 'open-tab',
          webpage: 'https://greasyfork.org/scripts/421603'
        }
      });
      this.btnnav = make('mujs-btn', 'nav', {
        title: 'Navigation',
        innerHTML: iconSVG.load('nav'),
        dataset: {
          command: 'navigation'
        }
      });
      const makeTHead = (rows = []) => {
        const tr = make('tr');
        for (const r of rows) {
          const tparent = make('th', r.class ?? '', r);
          tr.append(tparent);
        }
        this.tabhead.append(tr);
        this.table.append(this.tabhead, this.tabbody);
      };
      makeTHead([
        {
          class: 'mujs-header-name',
          textContent: i18n$('name')
        },
        {
          textContent: i18n$('createdby')
        },
        {
          textContent: i18n$('daily_installs')
        },
        {
          textContent: i18n$('updated')
        },
        {
          textContent: i18n$('install')
        }
      ]);
      // #endregion
      if (isMobile) {
        dom.cl.add([this.btnHide, this.btnfullscreen, this.closebtn], 'hidden');
        this.btnframe.append(
          this.btnHide,
          this.btnfullscreen,
          this.closebtn,
          this.btnhome,
          this.btngreasy,
          this.btnissue,
          this.btncfg,
          this.btnnav
        );
      } else {
        this.btnHandles.append(this.btnHide, this.btnfullscreen, this.closebtn);
        this.btnframe.append(this.btnhome, this.btngreasy, this.btnissue, this.btncfg, this.btnnav);
      }
      this.toolbar.append(this.btnHandles);
      this.urlContainer.append(this.urlBar);
      this.header.append(this.urlContainer, this.rateContainer, this.countframe, this.btnframe);
      this.tbody.append(this.table, this.cfgpage);
      this.main.append(this.toolbar, this.header, this.tbody, this.footer, this.promptElem);
      this.mainframe.append(this.mainbtn);
      this.root.append(this.mainframe, this.main);

      return true;
    } catch (ex) {
      err(ex);
    }
    return false;
  }
  remove() {
    this.userjsCache.clear();
    dom.remove(this.frame);
  }
  async save() {
    this.unsaved = false;
    await StorageSystem.setValue('Config', cfg);
    info('Saved config:', cfg);
    this.redirect();
    return cfg;
  }
  /**
   * @param { string } css - CSS to inject
   * @param { string } name - Name of stylesheet
   * @return { HTMLStyleElement | undefined } Style element
   */
  loadCSS(css, name = 'CSS', useGM = true) {
    try {
      if (this.stylesheet) return this.stylesheet;
      if (typeof name !== 'string')
        throw new Error('"name" must be a typeof "string"', { cause: 'loadCSS' });
      if (typeof css !== 'string')
        throw new Error('"css" must be a typeof "string"', { cause: 'loadCSS' });
      if (isBlank(css))
        throw new Error(`"${name}" contains empty CSS string`, { cause: 'loadCSS' });
      const parent = isEmpty(this.root.shadowRoot) ? this.root : this.root.shadowRoot;
      if (useGM && isGM) {
        const fn = (isFN(GM.addElement) && GM.addElement) || (isFN(GM_addElement) && GM_addElement);
        if (!isFN(fn)) return this.loadCSS(css, name, false);
        const sty = fn(parent, 'style', { textContent: css });
        if (isElem(sty)) {
          sty.dataset.insertedBy = $info.script.name;
          sty.dataset.role = name;
          this.stylesheet = sty;
          return this.stylesheet;
        }
      }
      const sty = make('style', {
        textContent: css,
        dataset: {
          insertedBy: $info.script.name,
          role: name
        }
      });
      parent.appendChild(sty);
      this.stylesheet = sty;
      return this.stylesheet;
    } catch (ex) {
      err(ex);
    }
  }
  checkBlacklist(str) {
    str = str || this.host;
    if (/accounts*\.google\./.test(this.webpage.host)) {
      this.isBlacklisted = true;
      return this.isBlacklisted;
    }
    let blacklisted = false;
    for (const b of normalizeTarget(cfg.blacklist)) {
      if (typeof b === 'string') {
        if (b.startsWith('userjs-')) {
          const [, r] = /userjs-(\w+)/.exec(b) ?? [];
          const biList = builtinList[r];
          if (isRegExp(biList)) {
            if (biList.test(str)) blacklisted = true;
          } else if (isObj(biList) && biList.host === this.host) {
            blacklisted = true;
          }
        }
      } else if (isObj(b)) {
        if (!b.enabled) continue;
        if (b.regex === true) {
          const reg = new RegExp(b.url, b.flags);
          if (reg.test(str)) blacklisted = true;
        }
        if (Array.isArray(b.url)) {
          for (const c of b.url) {
            if (str.includes(c)) blacklisted = true;
          }
        }
        if (str.includes(b.url)) blacklisted = true;
      }
    }
    this.isBlacklisted = blacklisted;
    return this.isBlacklisted;
  }
  setTheme() {
    const theme = cfg.theme ?? DEFAULT_CONFIG.theme;
    if (theme === DEFAULT_CONFIG.theme) {
      return;
    }
    const { style } = this.root;
    for (const [k, v] of Object.entries(theme)) {
      const str = `--mujs-${k}`;
      const prop = style.getPropertyValue(str);
      if (isEmpty(v)) theme[k] = prop;
      if (prop === v) continue;
      style.removeProperty(str);
      style.setProperty(str, v);
    }
  }
  makePrompt(txt, dataset = {}, usePrompt = true) {
    dom.remove(Container.prompts);
    const el = make('mu-js', 'prompt', {
      dataset: {
        prompt: txt
      }
    });
    const elHead = make('mu-js', 'prompt-head', {
      innerHTML: `${iconSVG.load('refresh')} ${txt}`
    });
    el.append(elHead);
    if (usePrompt) {
      const elPrompt = make('mu-js', 'prompt-body', { dataset });
      const elYes = make('mujs-btn', 'prompt-confirm', {
        innerHTML: 'Confirm',
        dataset: {
          command: 'prompt-confirm'
        }
      });
      const elNo = make('mujs-btn', 'prompt-deny', {
        innerHTML: 'Deny',
        dataset: {
          command: 'prompt-deny'
        }
      });
      elPrompt.append(elYes, elNo);
      el.append(elPrompt);
    } else {
      const elPrompt = make('mu-js', 'prompt-body');
      const elNo = make('mujs-btn', 'prompt-deny', {
        textContent: i18n$('close')
      });
      ael(elNo, isMobile ? 'touchend' : 'click', () => {
        el.remove();
      });
      elPrompt.append(elNo);
      el.append(elPrompt);
    }
    Container.prompts.push(el);
    this.promptElem.append(el);
    return el;
  }
  /**
   * @template {string | Error} E
   * @param {...E} ex
   */
  showError(...ex) {
    err(...ex);
    const error = make('mu-js', 'error');
    let str = '';
    for (const e of ex) {
      str += `${typeof e === 'string' ? e : `${e.cause ? `[${e.cause}] ` : ''}${e.message}${e.stack ? ` ${e.stack}` : ''}`}\n`;
    }
    error.appendChild(_self.createTextNode(str));
    this.footer.append(error);
  }
  refresh() {
    this.urlBar.placeholder = i18n$('newTab');
    Counter.reset();
    dom.cl.remove(this.toElem(), 'hidden');
    dom.cl.remove(this.cfgpage._mujs.sections, 'hidden');
    dom.prop([this.tabbody, this.rateContainer, this.footer], 'innerHTML', '');
  }
  /**
   * Redirects sleazyfork userscripts from greasyfork.org to sleazyfork.org
   *
   * Taken from: https://greasyfork.org/scripts/23840
   */
  redirect() {
    const locObj = window.top.location;
    const { hostname } = locObj;
    const gfSite = /greasyfork\.org/.test(hostname);
    if (!gfSite && cfg.sleazyredirect) return;
    const otherSite = gfSite ? 'sleazyfork' : 'greasyfork';
    if (!qs('span.sign-in-link')) return;
    if (!/scripts\/\d+/.test(locObj.href)) return;
    if (
      !qs('#script-info') &&
      (otherSite == 'greasyfork' || qs('div.width-constraint>section>p>a'))
    ) {
      const str = locObj.href.replace(
        /\/\/([^.]+\.)?(greasyfork|sleazyfork)\.org/,
        '//$1' + otherSite + '.org'
      );
      info(`Redirecting to "${str}"`);
      if (isFN(locObj.assign)) {
        locObj.assign(str);
      } else {
        locObj.href = str;
      }
    }
  }
  /**
   * @param {number} [time]
   */
  async timeoutFrame(time) {
    const frameTimeout = this.timeouts.frame;
    frameTimeout.clear(...frameTimeout.ids);
    if (dom.cl.has(this.mainframe, 'hidden')) {
      return;
    }
    time = time ?? cfg.time ?? DEFAULT_CONFIG.time;
    let n = 10000;
    if (typeof time === 'number' && !Number.isNaN(time)) {
      n = this.isBlacklisted ? time / 2 : time;
    }
    await frameTimeout.set(n);
    this.remove();
    frameTimeout.clear(...frameTimeout.ids);
  }
  toElem() {
    return Array.from(this).map(({ _mujs }) => {
      return _mujs.root;
    });
  }
  *[Symbol.iterator]() {
    const arr = Array.from(this.userjsCache.values()).filter(({ _mujs }) => {
      return !isEmpty(_mujs) && _mujs.info.engine.enabled;
    });
    for (const userjs of arr) {
      yield userjs;
    }
  }
};
const container = new Container();
// #endregion
// #region Primary Function
function primaryFN() {
  const respHandles = {
    build: BLANK_ASYNC_FN
  };
  try {
    const { scheduler } = _self;
    const {
      btnfullscreen,
      mainframe,
      main,
      Tabs,
      showError,
      cfgpage: {
        _mujs: { sections: cfgSec, base: cfgBase }
      }
    } = container;
    const reloadCfg = () => {
      for (const base of cfgBase) {
        const [, CONFIG, SUB_CONFIG] = /^(\w+)-(.+)/.exec(base.value) ?? [];
        let d = DEFAULT_CONFIG[base.value];
        let v = cfg[base.value];
        if (base.tag === 'engine') {
          const dEngine = DEFAULT_CONFIG.engines.find((engine) => engine.name === base.value);
          const vEngine = cfg.engines.find((engine) => engine.name === base.value);
          if (dEngine) d = dEngine;
          if (vEngine) v = vEngine;
        } else if (CONFIG) {
          d = DEFAULT_CONFIG[CONFIG][SUB_CONFIG];
          v = cfg[CONFIG][SUB_CONFIG];
        }
        base.cache = v;
        if (base.type === 'checkbox') {
          if (CONFIG) {
            if (CONFIG === 'filters') {
              base.elem.checked = cfg[CONFIG][SUB_CONFIG].enabled;
            } else {
              base.elem.checked = v;
            }
          } else if (base.tag === 'engine') {
            base.elem.checked = v.enabled;
            base.elemUrl.value = decode(v.query);
            base.elemUrl.placeholder = decode(d.query);
            if (base.elemToken) {
              base.elemToken = v.token;
            }
          }
        } else {
          base.elem.value = v;
        }
      }
      container.setTheme();
    };
    const doInstallProcess = async (installLink) => {
      const locObj = window.top.location;
      if (isFN(locObj.assign)) {
        locObj.assign(installLink.href);
      } else {
        locObj.href = installLink.href;
      }
      installLink.remove();
      await init();
    };
    const doDownloadProcess = async (details) => {
      if (!details.url) {
        return;
      }
      const a = make('a');
      a.href = details.url;
      a.setAttribute('download', details.filename || '');
      a.setAttribute('type', 'text/plain');
      a.dispatchEvent(new MouseEvent('click'));
      await init();
    };
    const applyTo = (ujs, name, elem, root) => {
      const n = ujs._mujs.code[name] ?? ujs._mujs.code.data_meta[name];
      if (isEmpty(n)) {
        const el = make('mujs-a', {
          textContent: i18n$('listing_none')
        });
        elem.append(el);
        return;
      }
      dom.prop(elem, 'innerHTML', '');
      dom.cl.remove(root, 'hidden');
      if (isObj(n)) {
        if (name === 'resource') {
          for (const [k, v] of Object.entries(n)) {
            const el = make('mujs-a', {
              textContent: k ?? 'ERROR'
            });
            if (v.startsWith('http')) {
              el.dataset.command = 'open-tab';
              el.dataset.webpage = v;
            }
            elem.append(el);
          }
        } else {
          const el = make('mujs-a', {
            textContent: n.text
          });
          if (n.domain) {
            el.dataset.command = 'open-tab';
            el.dataset.webpage = `https://${n.text}`;
          }
          elem.append(el);
        }
      } else if (typeof n === 'string') {
        const el = make('mujs-a', {
          textContent: n
        });
        elem.append(el);
      } else {
        for (const c of n) {
          if (typeof c === 'string' && c.startsWith('http')) {
            const el = make('mujs-a', {
              textContent: c,
              dataset: {
                command: 'open-tab',
                webpage: c
              }
            });
            elem.append(el);
          } else if (isObj(c)) {
            const el = make('mujs-a', {
              textContent: c.text
            });
            if (c.domain) {
              el.dataset.command = 'open-tab';
              el.dataset.webpage = `https://${c.text}`;
            }
            elem.append(el);
          } else {
            const el = make('mujs-a', {
              textContent: c
            });
            elem.append(el);
          }
        }
      }
    };
    // #region Main event handlers
    const frameTimeout = container.timeouts.frame;
    ael(main, isMobile ? 'touchend' : 'click', async (evt) => {
      try {
        if (isNull(evt.target)) return;
        /** @type { HTMLElement } */
        const t = evt.target;
        const target = t.closest('[data-command]');
        if (isNull(target)) return;
        let dataset = target.dataset;
        let cmd = dataset.command;
        if (/^prompt-/.test(target.dataset.command)) {
          dataset = target.parentElement.dataset;
          cmd = dataset.command;
          let pElem = target.parentElement.parentElement;
          if (/prompt-install/.test(target.dataset.command)) {
            pElem = target.parentElement.parentElement.parentElement;
            const a = make('a', {
              onclick(evt) {
                evt.preventDefault();
                doInstallProcess(evt.target);
              }
            });
            a.href = target.dataset.code_url;
            a.click();
          } else if (/prompt-download/.test(target.dataset.command)) {
            pElem = target.parentElement.parentElement.parentElement;
            const dataUserJS = container.userjsCache.get(+target.dataset.userjs);
            if (dataUserJS) {
              const code_obj = await dataUserJS._mujs.code.request(false, target.dataset.code_url);
              if (typeof code_obj.code === 'string')
                doDownloadProcess({
                  url: 'data:text/plain;charset=utf-8,' + encodeURIComponent(code_obj.code),
                  filename: `${dataUserJS.name}${isUserCSS(target.dataset.code_url) ? '.user.css' : '.user.js'}`
                });
            }
          }
          pElem.remove();
          return;
        }
        if (cmd === 'install-script') {
          const dataUserJS = container.userjsCache.get(+dataset.userjs);
          if (isNull(dataUserJS)) {
            return;
          }
          if (dataUserJS.code_urls.length > 1) {
            const list = make('mujs-list', {
              style: 'display: flex; flex-direction: column;'
            });
            for (const ujs of dataUserJS.code_urls) {
              const a = make('mujs-a', {
                title: ujs.code_url,
                textContent: ujs.name,
                dataset: {
                  command: 'prompt-install',
                  code_url: ujs.code_url
                }
              });
              list.append(a);
            }
            container.makePrompt(`Multiple detected: ${list.outerHTML}`, dataset, false);
          } else {
            const a = make('a', {
              onclick(evt) {
                evt.preventDefault();
                doInstallProcess(evt.target);
              }
            });
            a.href = dataUserJS.code_url;
            a.click();
          }
        } else if (/open-tab|more-info/.test(cmd) && dataset.webpage) {
          if (cmd === 'more-info') evt.preventDefault();
          con.log(cmd);
          if (isGM) {
            if (isFN(GM.openInTab)) {
              return GM.openInTab(dataset.webpage);
            } else if (isFN(GM_openInTab)) {
              return GM_openInTab(dataset.webpage, {
                active: true,
                insert: true
              });
            }
          }
          return window.open(dataset.webpage, '_blank');
        } else if (cmd === 'navigation') {
          for (const e of normalizeTarget(qsA('mujs-btn', target.parentElement)).filter(
            (e) => !dom.cl.has(e, 'nav')
          )) {
            dom.cl.toggle(e, 'hidden');
          }
        } else if (cmd === 'list-description') {
          const arr = [];
          const ignoreTags = new Set(['TD', 'MUJS-A', 'MU-JS']);
          /**
           * @type { import("../typings/UserJS.d.ts").mujsName }
           */
          const p = target.parentElement;
          for (const node of Object.values(p._mujs)) {
            if (ignoreTags.has(node.tagName)) {
              continue;
            }
            if (node.tagName === 'TEXTAREA' && isEmpty(node.value)) {
              continue;
            }
            arr.push(node);
          }
          if (target.nextElementSibling) {
            arr.push(target.nextElementSibling);
            if (target.nextElementSibling.nextElementSibling) {
              arr.push(target.nextElementSibling.nextElementSibling);
            }
          }
          if (dom.cl.has(arr[0], 'hidden')) {
            dom.cl.remove(arr, 'hidden');
          } else {
            dom.cl.add(arr, 'hidden');
          }
        } else if (cmd === 'close') {
          container.remove();
        } else if (cmd === 'fullscreen') {
          if (dom.cl.has(btnfullscreen, 'expanded')) {
            dom.cl.remove([btnfullscreen, main], 'expanded');
            dom.prop(btnfullscreen, 'innerHTML', iconSVG.load('expand'));
          } else {
            dom.cl.add([btnfullscreen, main], 'expanded');
            dom.prop(btnfullscreen, 'innerHTML', iconSVG.load('collapse'));
          }
        } else if (cmd === 'hide-list') {
          dom.cl.add(main, 'hidden');
          dom.cl.remove(mainframe, 'hidden');
          container.timeoutFrame();
        } else if (cmd === 'save') {
          container.rebuild = true;
          dom.prop(container.rateContainer, 'innerHTML', '');
          if (!dom.prop(target, 'disabled')) {
            const config = await container.save();
            if (container.rebuild) {
              if (config.autofetch) {
                respHandles.build();
              }
            }
            container.unsaved = false;
            container.rebuild = false;
          }
        } else if (cmd === 'reset') {
          cfg = DEFAULT_CONFIG;
          dom.remove(qsA('.error', container.footer));
          container.unsaved = true;
          container.rebuild = true;
          reloadCfg();
        } else if (cmd === 'settings') {
          if (container.unsaved) {
            showError('Unsaved changes');
          }
          Tabs.create('mujs:settings');
          container.rebuild = false;
        } else if (cmd === 'new-tab') {
          Tabs.create();
        } else if (cmd === 'switch-tab') {
          Tabs.active(target);
        } else if (cmd === 'close-tab' && target.parentElement) {
          Tabs.close(target.parentElement);
        } else if (cmd === 'download-userjs') {
          const dataUserJS = container.userjsCache.get(+dataset.userjs);
          if (isNull(dataUserJS)) {
            return;
          }

          if (dataUserJS.code_urls.length > 1) {
            const list = make('mujs-list', {
              style: 'display: flex; flex-direction: column;'
            });
            for (const ujs of dataUserJS.code_urls) {
              const a = make('mujs-a', {
                title: ujs.code_url,
                textContent: ujs.name,
                dataset: {
                  command: 'prompt-download',
                  code_url: ujs.code_url,
                  userjs: dataset.userjs
                }
              });
              list.append(a);
            }
            container.makePrompt(`Multiple detected: ${list.outerHTML}`, dataset, false);
          } else {
            const code_obj = await dataUserJS._mujs.code.request(false);
            if (typeof code_obj.code === 'string')
              doDownloadProcess({
                url: 'data:text/plain;charset=utf-8,' + encodeURIComponent(code_obj.code),
                filename: `${dataUserJS.name}${isUserCSS(dataUserJS.code_url) ? '.user.css' : '.user.js'}`
              });
          }
        } else if (cmd === 'load-userjs' || cmd === 'load-header') {
          if (!container.userjsCache.has(+dataset.userjs)) {
            return;
          }
          const codeArea = qs('textarea', target.parentElement.parentElement);
          if (!isEmpty(codeArea.value) && cmd === codeArea.dataset.load) {
            dom.cl.toggle(codeArea, 'hidden');
            return;
          }
          codeArea.dataset.load = cmd;
          const dataUserJS = container.userjsCache.get(+dataset.userjs);
          const code_obj = await dataUserJS._mujs.code.request();
          if (typeof code_obj.data_code_block !== 'string') {
            codeArea.value = 'An error occured';
            return;
          }
          codeArea.value =
            cmd === 'load-userjs' ? code_obj.data_code_block : code_obj.data_meta_block;
          dom.cl.remove(codeArea, 'hidden');
          for (const e of qsA(
            'mujs-column[data-el="matches"]',
            target.parentElement.parentElement
          )) {
            applyTo(dataUserJS, e.dataset.type, qs('.mujs-grants', e), e);
          }
        } else if (cmd === 'load-page') {
          if (!container.userjsCache.has(+dataset.userjs)) {
            return;
          }
          let pageArea = qs('mujs-page', target.parentElement.parentElement);
          if (!pageArea) {
            pageArea = make('mujs-page');
            target.parentElement.parentElement.append(pageArea);
            const dataUserJS = container.userjsCache.get(+dataset.userjs);
            const engine = dataUserJS._mujs.info.engine;
            let pageURL;
            if (engine.name.includes('fork')) {
              const {
                navigator: { language }
              } = _self;
              const { current } = Language;
              pageURL = dataUserJS.url.replace(
                /\/scripts/,
                `/${/^(zh|fr|es)/.test(current) ? language : current}/scripts`
              );
            } else if (engine.name.includes('github')) {
              const page_url = await Network.req(dataUserJS.page_url, 'GET', 'json', {
                headers: {
                  Accept: 'application/vnd.github+json',
                  Authorization: `Bearer ${engine.token}`,
                  'X-GitHub-Api-Version': '2022-11-28'
                }
              }).catch(() => {
                return {};
              });
              if (!page_url.download_url) {
                return;
              }
              const page = await Network.req(page_url.download_url, 'GET', 'text');
              if (container.shadowSupport) {
                const shadow = pageArea.attachShadow({ mode: 'closed' });
                const div = make('div', {
                  innerHTML: page
                });
                shadow.append(div);
              }
              return;
            } else {
              pageURL = dataUserJS.url;
            }
            if (!pageURL) {
              return;
            }
            const page = await Network.req(pageURL, 'GET', 'document');
            const getContent = () => {
              let content = 'An error occured';
              const h = new URL(dataUserJS.url);
              const root = qs('.user-content', page.documentElement);
              for (const e of qsA('[href]', root)) {
                e.target = '_blank';
                e.style = 'pointer-events: auto;';
                if (e.href.startsWith('/')) {
                  e.href = `${h.origin}${e.href}`;
                }
              }
              for (const e of qsA('img[src]', root)) {
                e.style =
                  'max-width: 25em; max-height: 25em; -webkit-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none;';
              }
              if (root) {
                content = root.innerHTML;
              } else {
                content = 'No additional info available';
              }
              return content;
            };
            if (container.shadowSupport) {
              const shadow = pageArea.attachShadow({ mode: 'closed' });
              const div = make('div', {
                style: 'pointer-events: none;',
                innerHTML: getContent()
              });
              shadow.append(div);
            }
            return;
          }
          if (!dom.cl.has(pageArea, 'hidden')) {
            dom.cl.add(pageArea, 'hidden');
            return;
          }
          dom.cl.remove(pageArea, 'hidden');
        } else if (/export-/.test(cmd)) {
          const toCfg = cmd === 'export-cfg';
          doDownloadProcess({
            url:
              'data:text/plain;charset=utf-8,' +
              encodeURIComponent(JSON.stringify(toCfg ? cfg : cfg.theme, null, ' ')),
            filename: `Magic_Userscript_${toCfg ? 'config' : 'theme'}.json`
          });
        } else if (/import-/.test(cmd)) {
          if (qs('input', target.parentElement)) {
            qs('input', target.parentElement).click();
            return;
          }
          const inpJSON = make('input', 'hidden', {
            type: 'file',
            accept: '.json',
            onchange(evt) {
              const file = evt.target.files[0];
              if (file === undefined || file.name === '') {
                return;
              }
              const fr = new FileReader();
              fr.onload = function () {
                if (typeof fr.result !== 'string') {
                  return;
                }
                const content = JSON.parse(fr.result);
                if (content.blacklist) {
                  cfg = content;
                  container.unsaved = true;
                  container.rebuild = true;
                  reloadCfg();
                  container.save().then((config) => {
                    if (config.autofetch) {
                      respHandles.build();
                    }
                    container.unsaved = false;
                    container.rebuild = false;
                  });
                } else {
                  cfg.theme = content;
                  container.setTheme();
                }
                inpJSON.remove();
              };
              fr.readAsText(file);
            }
          });
          target.parentElement.append(inpJSON);
          inpJSON.click();
        }
      } catch (ex) {
        showError(ex);
      }
    });
    ael(main, 'auxclick', (evt) => {
      if (evt.button !== 1) {
        return;
      }
      /** @type { HTMLElement } */
      const target = evt.target.closest('[data-command]');
      if (!target) {
        return;
      }
      const dataset = target.dataset;
      const cmd = dataset.command;
      if (cmd === 'switch-tab' || cmd === 'close-tab') {
        Tabs.close(target);
      } else if (cmd === 'new-tab') {
        Tabs.create();
      }
    });
    if (!isMobile) {
      const fade = async (target, type) => {
        if (type === 'mouseenter') {
          frameTimeout.clear(...frameTimeout.ids);
          container.timeouts.mouse.clear(...container.timeouts.mouse.ids);
          target.style.opacity = container.opacityMax;
        } else if (type === 'mouseleave') {
          await container.timeouts.mouse.set(cfg.time);
          target.style.opacity = container.opacityMin;
        }
      };
      for (const e of ['mouseenter', 'mouseleave']) {
        ael(main, e, (evt) => {
          evt.preventDefault();
          evt.stopPropagation();
          fade(evt.target, evt.type);
        });
      }
    }
    /**
     * @param {CustomEvent<import("../typings/types.d.ts").GSForkQuery>} evt
     */
    const updatedItem = (evt) => {
      const ujs = evt.detail;
      if (!ujs._mujs) return;
      if (ujs.deleted === true) {
        ujs._mujs.root.remove();
        container.userjsCache.delete(ujs.id);
        Counter.reset();
        MUList.sortRecords();
        return;
      }
      if (!isEmpty(ujs.code_urls)) ujs.code_url = ujs.code_urls[0].code_url;
      for (const elem of qsA('[data-name]', ujs._mujs.root)) {
        const name = elem.dataset.name;
        if (name === 'code') {
          if (ujs._mujs.code.data_code_block) {
            if (cfg.preview.code && !cfg.preview.metadata) {
              elem.value = ujs._mujs.code.data_code_block;
            } else if (cfg.preview.metadata && !cfg.preview.code) {
              elem.value = ujs._mujs.code.data_meta_block;
            } else {
              elem.value = `${ujs._mujs.code.META_START_COMMENT}${ujs._mujs.code.data_meta_block}${ujs._mujs.code.META_END_COMMENT}${ujs._mujs.code.data_code_block}`;
            }
          }
          continue;
        }
        if (!ujs[name]) continue;
        if (name === 'license') {
          dom.attr(elem, 'title', ujs.license ?? i18n$('no_license'));
          dom.text(elem, `${i18n$('license')}: ${ujs.license ?? i18n$('no_license')}`);
        } else if (name === 'code_updated_at') {
          dom.text(elem, Language.toDate(ujs.code_updated_at));
          elem.dataset.value = new Date(ujs.code_updated_at).toISOString();
        } else if (name === 'created_date') {
          dom.text(elem, `${i18n$('created_date')}: ${Language.toDate(ujs.created_at)}`);
          elem.dataset.value = new Date(ujs.created_at).toISOString();
        } else if (name === 'total_installs') {
          dom.text(elem, `${i18n$('total_installs')}: ${Language.toNumber(ujs.total_installs)}`);
        } else {
          dom.text(elem, ujs[name]);
        }
      }
      if (ujs._mujs.code.data_code_block) {
        for (const e of qsA('mujs-column[data-el="matches"]', ujs._mujs.root)) {
          applyTo(ujs, e.dataset.type, qs('.mujs-grants', e), e);
        }
      }
      if (container.userjsCache.has(ujs.id)) container.userjsCache.set(ujs.id, ujs);
    };
    ael(main, 'updateditem', updatedItem);
    // #endregion
    const TLD_EXPANSION = ['com', 'net', 'org', 'de', 'co.uk'];
    const APPLIES_TO_ALL_PATTERNS = [
      'http://*',
      'https://*',
      'http://*/*',
      'https://*/*',
      'http*://*',
      'http*://*/*',
      '*',
      '*://*',
      '*://*/*',
      'http*'
    ];
    class ParseUserJS {
      /**
       * @type { string }
       */
      code;
      /**
       * @type { string }
       */
      data_meta_block;
      /**
       * @type { string }
       */
      data_code_block;
      /**
       * @type { { [meta: string]: string | string[] | { [resource: string]: string } } }
       */
      data_meta;
      /**
       * @type { {text: string;domain: boolean;tld_extra: boolean}[] }
       */
      data_names;
      constructor(code, isCSS) {
        this.isUserCSS = isCSS === true;
        this.META_START_COMMENT = this.isUserCSS ? '/* ==UserStyle==' : '// ==UserScript==';
        this.META_END_COMMENT = this.isUserCSS ? '==/UserStyle== */' : '// ==/UserScript==';
        if (code) {
          this.code = code;
          this.get_meta_block();
          this.get_code_block();
          this.parse_meta();
          this.calculate_applies_to_names();
        }
      }
      get_meta_block() {
        if (isEmpty(this.code)) {
          return '';
        }
        if (this.data_meta_block) {
          return this.data_meta_block;
        }
        const start_block = this.code.indexOf(this.META_START_COMMENT);
        if (isNull(start_block)) {
          return '';
        }
        const end_block = this.code.indexOf(this.META_END_COMMENT, start_block);
        if (isNull(end_block)) {
          return '';
        }
        const meta_block = this.code.substring(
          start_block + this.META_START_COMMENT.length,
          end_block
        );
        this.data_meta_block = meta_block;
        return this.data_meta_block;
      }
      get_code_block() {
        if (isEmpty(this.code)) {
          return '';
        }
        if (this.data_code_block) {
          return this.data_code_block;
        }
        const start_block = this.code.indexOf(this.META_START_COMMENT);
        if (isNull(start_block)) {
          return null;
        }
        const end_block = this.code.indexOf(this.META_END_COMMENT, start_block);
        if (isNull(end_block)) {
          return null;
        }
        const code_block = this.code.substring(
          end_block + this.META_END_COMMENT.length,
          this.code.length
        );
        this.data_code_block = code_block.split('\n').filter(Boolean).join('\n');
        return this.data_code_block;
      }
      parse_meta() {
        if (isEmpty(this.code)) {
          return {};
        }
        if (this.data_meta) {
          return this.data_meta;
        }
        const meta = {};
        const meta_block_map = new Map();
        const reg = (this.isUserCSS && /@([a-zA-Z:-]+)\s+(.*)/) || /\/\/\s+@([a-zA-Z:-]+)\s+(.*)/;
        for (const meta_line of this.get_meta_block().split('\n').filter(Boolean)) {
          let [, key, value] = reg.exec(meta_line) ?? [];
          if (!key) continue;
          key = key.trim();
          value = value.trim();
          if (!meta_block_map.has(key)) meta_block_map.set(key, []);
          const meta_map = meta_block_map.get(key);
          meta_map.push(value);
          meta_block_map.set(key, meta_map);
        }
        for (const [key, value] of meta_block_map) {
          if (value.length > 1) {
            meta[key] = value;
          } else {
            meta[key] = value[0];
          }
        }
        this.data_meta = meta;
        return this.data_meta;
      }
      calculate_applies_to_names() {
        if (isEmpty(this.code)) {
          return [];
        }
        if (this.data_names) {
          return this.data_names;
        }
        let patterns = [];
        for (const [k, v] of Object.entries(this.parse_meta())) {
          if (/include|match/i.test(k)) {
            if (Array.isArray(v)) {
              patterns = patterns.concat(v);
            } else {
              patterns = patterns.concat([v]);
            }
          }
        }
        if (isEmpty(patterns)) {
          return [];
        }
        if (this.intersect(patterns, APPLIES_TO_ALL_PATTERNS)) {
          this.data_names = [
            {
              domain: false,
              text: 'All sites',
              tld_extra: false
            }
          ];
          return this.data_names;
        }
        this.data_names = ParseUserJS.getNames(patterns);
        return this.data_names;
      }
      intersect(a, ...arr) {
        return !isBlank([...new Set(a)].filter((v) => arr.every((b) => b.includes(v))));
      }
      static getNames(patterns = []) {
        const name_map = new Map();
        const addObj = (obj) => {
          if (name_map.has(obj.text)) {
            return;
          }
          name_map.set(obj.text, obj);
        };
        for (let p of patterns) {
          const original_pattern = p;
          let pre_wildcards = [];
          if (p.match(/^\/(.*)\/$/)) {
            pre_wildcards = [p];
          } else {
            let m = /^\*(https?:.*)/i.exec(p);
            if (m) {
              p = m[1];
            }
            p = p
              .replace(/^\*:/i, 'http:')
              .replace(/^\*\/\//i, 'http://')
              .replace(/^http\*:/i, 'http:')
              .replace(/^(https?):([^/])/i, '$1://$2');
            m = /^([a-z]+:\/\/)\*\.?([a-z0-9-]+(?:.[a-z0-9-]+)+.*)/i.exec(p);
            if (m) {
              p = m[1] + m[2];
            }
            m = /^\*\.?([a-z0-9-]+\.[a-z0-9-]+.*)/i.exec(p);
            if (m) {
              p = `http://${m[1]}`;
            }
            m = /^http\*(?:\/\/)?\.?((?:[a-z0-9-]+)(?:\.[a-z0-9-]+)+.*)/i.exec(p);
            if (m) {
              p = `http://${m[1]}`;
            }
            m = /^([a-z]+:\/\/([a-z0-9-]+(?:\.[a-z0-9-]+)*\.))\*(.*)/.exec(p);
            if (m) {
              if (m[2].match(/A([0-9]+\.){2,}z/)) {
                p = `${m[1]}tld${m[3]}`;
                pre_wildcards = [p.split('*')[0]];
              } else {
                pre_wildcards = [p];
              }
            } else {
              pre_wildcards = [p];
            }
          }
          for (const pre_wildcard of pre_wildcards) {
            try {
              const urlObj = new URL(pre_wildcard);
              const { host } = urlObj;
              if (isNull(host)) {
                addObj({ text: original_pattern, domain: false, tld_extra: false });
              } else if (!host.includes('.') && host.includes('*')) {
                addObj({ text: original_pattern, domain: false, tld_extra: false });
              } else if (host.endsWith('.tld')) {
                for (let i = 0; i < TLD_EXPANSION.length; i++) {
                  const tld = TLD_EXPANSION[i];
                  addObj({
                    text: host.replace(/tld$/i, tld),
                    domain: true,
                    tld_extra: i != 0
                  });
                }
              } else if (host.endsWith('.')) {
                addObj({
                  text: host.slice(0, -1),
                  domain: true,
                  tld_extra: false
                });
              } else {
                addObj({
                  text: host,
                  domain: true,
                  tld_extra: false
                });
              }
            } catch {
              addObj({ text: original_pattern, domain: false, tld_extra: false });
            }
          }
        }
        return [...name_map.values()];
      }
      /**
       * @template {import("../typings/types.d.ts").GSForkQuery} O
       * @param {boolean} translate
       * @param {O["code_url"]} code_url
       * @param {O} [obj]
       */
      async request(translate = false, code_url, obj) {
        if (this.data_code_block) {
          return this;
        }
        /** @type { string } */
        const code = await Network.req(code_url, 'GET', 'text').catch(err);
        if (typeof code !== 'string') {
          return this;
        }
        this.isUserCSS = isUserCSS(code_url);
        this.META_START_COMMENT = this.isUserCSS ? '/* ==UserStyle==' : '// ==UserScript==';
        this.META_END_COMMENT = this.isUserCSS ? '==/UserStyle== */' : '// ==/UserScript==';
        this.code = code;
        this.get_meta_block();
        this.get_code_block();
        this.parse_meta();
        this.calculate_applies_to_names();

        const { data_meta } = this;
        if (translate) {
          if (data_meta[`name:${Language.current}`]) {
            Object.assign(obj, {
              name: data_meta[`name:${Language.current}`]
            });
            this.translated = true;
          }
          if (data_meta[`description:${Language.current}`]) {
            Object.assign(obj, {
              description: data_meta[`description:${Language.current}`]
            });
            this.translated = true;
          }
        }
        if (Array.isArray(data_meta.grant)) {
          data_meta.grant = union(data_meta.grant);
        }
        if (data_meta.resource) {
          const obj = {};
          if (typeof data_meta.resource === 'string') {
            const [, key, value] = /(.+)\s+(.+)/.exec(data_meta.resource) ?? [];
            if (key) {
              obj[key.trim()] = value;
            }
          } else {
            for (const r of data_meta.resource) {
              const [, key, value] = /(.+)\s+(http.+)/.exec(r) ?? [];
              if (key) {
                obj[key.trim()] = value;
              }
            }
          }
          data_meta.resource = obj;
        }
        Object.assign(this, {
          code_size: [Network.format(code.length)],
          meta: data_meta
        });

        return this;
      }
    }
    const template = {
      id: 0,
      bad_ratings: 0,
      good_ratings: 0,
      ok_ratings: 0,
      daily_installs: 0,
      total_installs: 0,
      name: 'NOT FOUND',
      description: 'NOT FOUND',
      version: '0.0.0',
      url: BLANK_PAGE,
      code_url: BLANK_PAGE,
      created_at: Date.now(),
      code_updated_at: Date.now(),
      locale: 'NOT FOUND',
      deleted: false,
      users: []
    };
    const mkList = (txt = '', obj = {}) => {
      if (!obj.root || !obj.type) return;
      const { root, type } = obj;
      const appliesTo = make('mu-js', 'mujs-list', {
        textContent: `${txt}: `
      });
      const applyList = make('mu-js', 'mujs-grants');
      const ujsURLs = make('mujs-column', 'mujs-list', {
        dataset: {
          el: 'matches',
          type
        }
      });
      ujsURLs.append(appliesTo, applyList);
      root.append(ujsURLs);
      const list = obj.list ?? [];
      if (isEmpty(list)) {
        const elem = make('mujs-a', {
          textContent: i18n$('listing_none')
        });
        applyList.append(elem);
        dom.cl.add(ujsURLs, 'hidden');
        return;
      }
      for (const c of list) {
        if (typeof c === 'string' && c.startsWith('http')) {
          const elem = make('mujs-a', {
            textContent: c,
            dataset: {
              command: 'open-tab',
              webpage: c
            }
          });
          applyList.append(elem);
        } else if (isObj(c)) {
          if (type === 'resource') {
            for (const [k, v] of Object.entries(c)) {
              const elem = make('mujs-a', {
                textContent: k ?? 'ERROR'
              });
              if (v.startsWith('http')) {
                elem.dataset.command = 'open-tab';
                elem.dataset.webpage = v;
              }
              applyList.append(elem);
            }
          } else {
            const elem = make('mujs-a', {
              textContent: c.text
            });
            if (c.domain) {
              elem.dataset.command = 'open-tab';
              elem.dataset.webpage = `https://${c.text}`;
            }
            applyList.append(elem);
          }
        } else {
          const elem = make('mujs-a', {
            textContent: c
          });
          applyList.append(elem);
        }
      }
    };
    // #region Create UserJS
    /**
     * @param { import("../typings/types.d.ts").GSForkQuery } ujs
     * @param { string } engine
     */
    const createjs = (ujs, engine) => {
      const a = [
        ujs.deleted === true,
        ujs.id === 421603, // Lets not add this UserJS to the list
        badUserJS.includes(ujs.id),
        badUserJS.includes(ujs.url)
      ].some((t) => t === true);
      if (a) return;
      if (!container.userjsCache.has(ujs.id)) container.userjsCache.set(ujs.id, ujs);
      const eframe = make('td', 'install-btn');
      const uframe = make('td', 'mujs-uframe');
      const fdaily = make('td', 'mujs-list', {
        textContent: ujs.daily_installs,
        dataset: {
          name: 'daily_installs'
        }
      });
      const fupdated = make('td', 'mujs-list', {
        textContent: Language.toDate(ujs.code_updated_at),
        dataset: {
          name: 'code_updated_at',
          value: new Date(ujs.code_updated_at).toISOString()
        }
      });
      /**
       * @type { import("../typings/UserJS.d.ts").mujsName }
       */
      const fname = make('td', 'mujs-name');
      const fmore = make('mujs-column', 'mujs-list hidden', {
        dataset: {
          el: 'more-info'
        }
      });
      const fBtns = make('mujs-column', 'mujs-list hidden');
      const jsInfo = make('mujs-row', 'mujs-list');
      const jsInfoB = make('mujs-row', 'mujs-list');
      const ratings = make('mujs-column', 'mujs-list');
      const ftitle = make('mujs-a', 'mujs-homepage', {
        textContent: ujs.name,
        title: ujs.url,
        dataset: {
          command: 'open-tab',
          webpage: ujs.url
        }
      });
      const fver = make('mu-js', 'mujs-list', {
        textContent: `${i18n$('version_number')}: ${ujs.version}`
      });
      const fcreated = make('mu-js', 'mujs-list', {
        textContent: `${i18n$('created_date')}: ${Language.toDate(ujs.created_at)}`,
        dataset: {
          name: 'created_at',
          value: new Date(ujs.created_at).toISOString()
        }
      });
      const flicense = make('mu-js', 'mujs-list', {
        title: ujs.license ?? i18n$('no_license'),
        textContent: `${i18n$('license')}: ${ujs.license ?? i18n$('no_license')}`,
        dataset: {
          name: 'license'
        }
      });
      const ftotal = make('mu-js', 'mujs-list', {
        textContent: `${i18n$('total_installs')}: ${Language.toNumber(ujs.total_installs)}`,
        dataset: {
          name: 'total_installs'
        }
      });
      const fratings = make('mu-js', 'mujs-list', {
        title: i18n$('ratings'),
        textContent: `${i18n$('ratings')}:`
      });
      const fgood = make('mu-js', 'mujs-list mujs-ratings', {
        title: i18n$('good'),
        textContent: ujs.good_ratings,
        dataset: {
          name: 'good_ratings',
          el: 'good'
        }
      });
      const fok = make('mu-js', 'mujs-list mujs-ratings', {
        title: i18n$('ok'),
        textContent: ujs.ok_ratings,
        dataset: {
          name: 'ok_ratings',
          el: 'ok'
        }
      });
      const fbad = make('mu-js', 'mujs-list mujs-ratings', {
        title: i18n$('bad'),
        textContent: ujs.bad_ratings,
        dataset: {
          name: 'bad_ratings',
          el: 'bad'
        }
      });
      const fdesc = make('mu-js', 'mujs-list mujs-pointer', {
        title: ujs.description,
        textContent: ujs.description,
        dataset: {
          command: 'list-description'
        }
      });
      const scriptInstall = make('mu-jsbtn', 'install', {
        innerHTML: `${iconSVG.load('install')} ${i18n$('install')}`,
        title: `${i18n$('install')} "${ujs.name}"`,
        dataset: {
          command: 'install-script',
          userjs: ujs.id
        }
      });
      const scriptDownload = make('mu-jsbtn', {
        innerHTML: `${iconSVG.load('download')} ${i18n$('saveFile')}`,
        dataset: {
          command: 'download-userjs',
          userjs: ujs.id,
          userjsName: ujs.name
        }
      });
      const tr = make('tr', 'frame', {
        dataset: {
          engine,
          scriptId: ujs.id
        }
      });
      const codeArea = make('textarea', 'code-area hidden', {
        dataset: {
          name: 'code'
        },
        rows: '10',
        autocomplete: false,
        spellcheck: false,
        wrap: 'soft'
      });
      const loadCode = make('mu-jsbtn', {
        innerHTML: `${iconSVG.load('code')} ${i18n$('code')}`,
        dataset: {
          command: 'load-userjs',
          userjs: ujs.id
        }
      });
      const loadMetadata = make('mu-jsbtn', {
        innerHTML: `${iconSVG.load('code')} ${i18n$('metadata')}`,
        dataset: {
          command: 'load-header',
          userjs: ujs.id
        }
      });
      if (!engine.includes('fork') && cfg.recommend.others && goodUserJS.includes(ujs.url)) {
        tr.dataset.good = 'upsell';
      }
      for (const u of ujs.users) {
        const user = make('mujs-a', {
          innerHTML: u.name,
          title: u.url,
          dataset: {
            command: 'open-tab',
            webpage: u.url
          }
        });
        if (
          cfg.recommend.author &&
          (u.id === authorID || u.url === 'https://github.com/magicoflolis')
        ) {
          tr.dataset.author = 'upsell';
          dom.prop(user, 'innerHTML', `${u.name} ${iconSVG.load('verified')}`);
        }
        uframe.append(user);
      }
      if (cfg.recommend.others && goodUserJS.includes(ujs.id)) {
        tr.dataset.good = 'upsell';
      }
      eframe.append(scriptInstall);
      ratings.append(fratings, fgood, fok, fbad);
      jsInfo.append(ftotal, ratings, fver, fcreated);
      mkList(i18n$('code_size'), {
        list: ujs._mujs.code.code_size,
        type: 'code_size',
        root: jsInfo
      });

      jsInfoB.append(flicense);
      const data_meta = ujs._mujs.code?.data_meta ?? {};
      mkList(i18n$('antifeatures'), {
        list: data_meta.antifeatures ?? [],
        type: 'antifeatures',
        root: jsInfoB
      });
      mkList(i18n$('applies_to'), {
        list: ujs._mujs.code?.data_names ?? [],
        type: 'data_names',
        root: jsInfoB
      });
      mkList('@grant', {
        list: data_meta.grant ?? [],
        type: 'grant',
        root: jsInfoB
      });
      mkList('@require', {
        list: data_meta.require,
        type: 'require',
        root: jsInfoB
      });
      mkList('@resource', {
        list: isNull(data_meta.resource) ? [] : [data_meta.resource],
        type: 'resource',
        root: jsInfoB
      });
      fmore.append(jsInfo, jsInfoB);
      fBtns.append(scriptDownload, loadCode, loadMetadata);
      fname.append(ftitle, fdesc, fmore, fBtns, codeArea);
      fname._mujs = { fmore, fBtns, codeArea };

      const loadPage = make('mu-jsbtn', {
        innerHTML: `${iconSVG.load('pager')} Page`,
        dataset: {
          command: 'load-page',
          userjs: ujs.id
        }
      });
      fBtns.append(loadPage);

      if (ujs._mujs.code?.translated) tr.classList.add('translated');

      for (const e of [fname, uframe, fdaily, fupdated, eframe]) tr.append(e);
      ujs._mujs.root = tr;
      return ujs._mujs.root;
    };
    // #endregion
    const loadFilters = () => {
      /** @type {Map<string, import("../typings/types.d.ts").Filters >} */
      const pool = new Map();
      const handles = {
        pool,
        enabled() {
          return [...pool.values()].filter((o) => o.enabled);
        },
        refresh() {
          if (!Object.is(pool.size, 0)) pool.clear();
          for (const [key, value] of Object.entries(cfg.filters)) {
            if (!pool.has(key))
              pool.set(key, {
                ...value,
                reg: new RegExp(value.regExp, value.flag),
                keyReg: new RegExp(key.trim().toLocaleLowerCase(), 'gi'),
                valueReg: new RegExp(value.name.trim().toLocaleLowerCase(), 'gi')
              });
          }
          return this;
        },
        get(str) {
          return [...pool.values()].find((v) => v.keyReg.test(str) || v.valueReg.test(str));
        },
        /**
         * @param { import("../typings/types.d.ts").GSForkQuery } param0
         */
        match({ name, users }) {
          const p = handles.enabled();
          if (Object.is(p.length, 0)) return true;
          for (const v of p) {
            if ([{ name }, ...users].find((o) => o.name.match(v.reg))) return false;
          }
          return true;
        }
      };
      for (const [key, value] of Object.entries(cfg.filters)) {
        if (!pool.has(key))
          pool.set(key, {
            ...value,
            reg: new RegExp(value.regExp, value.flag),
            keyReg: new RegExp(key.trim().toLocaleLowerCase(), 'gi'),
            valueReg: new RegExp(value.name.trim().toLocaleLowerCase(), 'gi')
          });
      }
      return handles.refresh();
    };
    // #region List
    /**
     * @type { typeof import("../typings/UserJS.d.ts").List }
     */
    const List = class {
      #intEngines;
      #intHost;
      constructor(hostname = undefined) {
        this.build = this.build.bind(this);
        this.groupBy = this.groupBy.bind(this);
        this.dispatch = this.dispatch.bind(this);
        this.sortRecords = this.sortRecords.bind(this);
        this.#intEngines = cfg.engines ?? [];
        this.setHost(hostname);
      }

      setEngines(engines = []) {
        const { host } = this;
        const e = engines.filter((e) => {
          if (!e.enabled) {
            return false;
          }
          const v = engineUnsupported[e.name] ?? [];
          if (v.includes(host)) {
            showError(`Engine: "${e.name}" unsupported on "${host}"`);
            container.timeoutFrame();
            return false;
          }
          return true;
        });
        this.#intEngines = e;
        return e;
      }

      setHost(hostname) {
        if (isEmpty(hostname)) hostname = container.host;
        this.#intHost = hostname;
        this.blacklisted = container.checkBlacklist(hostname);
        this.#intEngines = this.setEngines(this.engines);
        this.domain = this.getDomain(this.#intHost);
        if (this.blacklisted) {
          showError(`Blacklisted "${hostname}"`);
          container.timeoutFrame();
        }
        return hostname;
      }

      dispatch(ujs) {
        const { CustomEvent } = _self;
        const customEvent = new CustomEvent('updateditem', { detail: ujs });
        main.dispatchEvent(customEvent);
      }

      get engines() {
        return this.#intEngines;
      }

      get host() {
        return this.#intHost;
      }

      getDomain(str = '') {
        if (str === '*') {
          return 'all-sites';
        }
        return str.split('.').at(-2) ?? BLANK_PAGE;
      }

      // #region Builder
      build() {
        try {
          container.refresh();
          const { blacklisted, engines, host, domain, dispatch } = this;
          if (blacklisted || isEmpty(engines)) {
            container.opacityMin = '0';
            mainframe.style.opacity = container.opacityMin;
            return;
          }
          const fetchRecords = [];
          const bsFilter = loadFilters();
          const hostCache = Array.from(this);

          info('Building list', { hostCache, engines, container, list: this });

          const g = this.groupBy();
          const toFetch = engines.filter((engine) => !g[engine.name]);
          const isCached = toFetch.filter((engine) =>
            hostCache.find(({ _mujs }) => engine.name === _mujs.info.engine.name)
          );
          if (!isBlank(toFetch) && isBlank(isCached)) {
            for (const engine of engines) {
              info(`Fetching from "${engine.name}" for "${host}"`);
              const respError = (error) => {
                if (!error.cause) error.cause = engine.name;
                if (error.message.startsWith('429')) {
                  showError(`Engine: "${engine.name}" Too many requests...`);
                  return;
                }
                showError(`Engine: "${engine.name}"`, error.message);
              };
              const _mujs = (d) => {
                /**
                 * @type {import("../typings/types.d.ts").GSForkQuery}
                 */
                const ujs = {
                  ...template,
                  ...d,
                  code_urls: [],
                  _mujs: {
                    root: {},
                    info: {
                      engine,
                      host
                    },
                    code: {
                      meta: {}
                    }
                  }
                };
                ujs._mujs.code.request = async (translate = false, code_url) => {
                  if (typeof ujs._mujs.code.data_code_block === 'string') {
                    return ujs._mujs.code;
                  }
                  const p = new ParseUserJS();
                  await p.request(translate, code_url ?? ujs.code_url, ujs);
                  if (code_url) {
                    return p;
                  }
                  for (const [k, v] of Object.entries(p)) ujs._mujs.code[k] = v;
                  return ujs._mujs.code;
                };
                return ujs;
              };
              /**
               * Prior to UserScript v7.0.0
               * @template {string} F
               * @param {F} fallback
               * @returns {F}
               */
              const toQuery = (fallback) => {
                if (engine.query) {
                  return decode(engine.query)
                    .replace(/\{host\}/g, host)
                    .replace(/\{domain\}/g, domain);
                }
                return fallback;
              };
              /**
               * @param { import("../typings/types.d.ts").GSFork } dataQ
               */
              const forkFN = async (dataQ) => {
                if (!dataQ) {
                  showError('Invalid data received from the server, check internet connection');
                  return;
                }
                const dq = Array.isArray(dataQ)
                  ? dataQ
                  : Array.isArray(dataQ.query)
                    ? dataQ.query
                    : [];
                const dataA = dq
                  .filter(Boolean)
                  .filter((d) => !d.deleted)
                  .filter(bsFilter.match);
                if (isBlank(dataA)) {
                  return;
                }
                const { groupBy } = _self;
                const g = groupBy(dataA.map(_mujs), ({ locale }) => {
                  const [current = locale] = locale.split('-');
                  return current;
                });
                for (const [k, list] of Object.entries(g)) {
                  if (!list) break;
                  for (const ujs of list) {
                    if (cfg.filterlang && k !== Language.current) {
                      const c = await ujs._mujs.code.request(true);
                      if (!c.translated) continue;
                    }
                    if (
                      !ujs._mujs.code.data_code_block &&
                      (cfg.preview.code || cfg.preview.metadata)
                    ) {
                      ujs._mujs.code.request().then(() => {
                        dispatch(ujs);
                      });
                    }
                    if (isUserCSS(ujs.code_url)) {
                      ujs.code_urls.push(
                        {
                          name: `${ujs.name} (.user.css)`,
                          code_url: ujs.code_url
                        },
                        {
                          name: `${ujs.name} (.user.js)`,
                          code_url: ujs.code_url.replace(/\.user\.css$/, '.user.js')
                        }
                      );
                    }
                    createjs(ujs, engine.name);
                  }
                }
              };
              /**
               * @param {Document} htmlDocument
               */
              const openuserjs = async (htmlDocument) => {
                try {
                  if (!htmlDocument) {
                    showError('Invalid data received from the server, TODO fix this');
                    return;
                  }
                  const d = htmlDocument.documentElement;
                  if (/openuserjs/gi.test(engine.name)) {
                    const col = qsA('.col-sm-8 .tr-link', d) ?? [];
                    for (const i of col) {
                      while (isNull(qs('.script-version', i))) {
                        await new Promise((resolve) => requestAnimationFrame(resolve));
                      }
                      const fixurl = dom
                        .prop(qs('.tr-link-a', i), 'href')
                        .replace(
                          new RegExp(document.location.origin, 'gi'),
                          'https://openuserjs.org'
                        );
                      const ujs = _mujs({
                        name: dom.text(qs('.tr-link-a', i)),
                        description: dom.text(qs('p', i)),
                        version: dom.text(qs('.script-version', i)),
                        url: fixurl,
                        code_url: `${fixurl.replace(/\/scripts/gi, '/install')}.user.js`,
                        total_installs: dom.text(qs('td:nth-child(2) p', i)),
                        created_at: dom.attr(qs('td:nth-child(4) time', i), 'datetime'),
                        code_updated_at: dom.attr(qs('td:nth-child(4) time', i), 'datetime'),
                        users: [
                          {
                            name: dom.text(qs('.inline-block a', i)),
                            url: dom.prop(qs('.inline-block a', i), 'href')
                          }
                        ]
                      });
                      if (bsFilter.match(ujs)) {
                        continue;
                      }
                      if (
                        !ujs._mujs.code.data_code_block &&
                        (cfg.preview.code || cfg.preview.metadata)
                      ) {
                        ujs._mujs.code.request().then(() => {
                          dispatch(ujs);
                        });
                      }
                      createjs(ujs, engine.name);
                    }
                  }
                } catch (ex) {
                  showError(ex);
                }
              };
              const gitFN = (data) => {
                try {
                  if (isBlank(data.items)) {
                    return;
                  }
                  for (const r of data.items) {
                    const ujs = _mujs({
                      id: r.id ?? 0,
                      name: r.name,
                      description: isEmpty(r.description) ? i18n$('no_license') : r.description,
                      url: r.html_url,
                      code_url: r.html_url,
                      page_url: `${r.url}/contents/README.md`,
                      created_at: r.created_at,
                      code_updated_at: r.updated_at || Date.now(),
                      daily_installs: r.watchers_count ?? 0,
                      good_ratings: r.stargazers_count ?? 0,
                      users: [
                        {
                          name: r.owner.login,
                          url: r.owner.html_url
                        }
                      ]
                    });
                    if (r.license?.name) ujs.license = r.license.name;
                    const rootPath = r.contents_url.replace(/\{\+path\}/, '');
                    const fetchContent = async (dir) => {
                      const contents = await Network.req(dir, 'GET', 'json', {
                        headers: {
                          Accept: 'application/vnd.github+json',
                          Authorization: `Bearer ${engine.token}`,
                          'X-GitHub-Api-Version': '2022-11-28'
                        }
                      }).catch(respError);
                      for (const content of contents) {
                        if (content.type === 'file') {
                          if (isUserJS(content.name)) {
                            ujs.code_urls.push({
                              name: content.name,
                              code_url: content.download_url
                            });
                          } else if (isUserCSS(content.name)) {
                            ujs.code_urls.push({
                              name: content.name,
                              code_url: content.download_url
                            });
                          }
                        } else if (content.type === 'dir') {
                          await fetchContent(`${rootPath}/${content.path}`);
                        }
                      }
                    };
                    fetchContent(rootPath).then(() => {
                      if (isEmpty(ujs.code_urls)) {
                        ujs.deleted = true;
                      } else if (
                        !ujs._mujs.code.data_code_block &&
                        (cfg.preview.code || cfg.preview.metadata)
                      ) {
                        ujs._mujs.code.request().then(() => {
                          dispatch(ujs);
                        });
                        return;
                      }
                      dispatch(ujs);
                    });
                    createjs(ujs, engine.name);
                  }
                } catch (ex) {
                  showError(ex);
                }
              };
              let netFN;
              if (/github/gi.test(engine.name)) {
                if (isEmpty(engine.token)) {
                  showError(`"${engine.name}" requires a token to use`);
                  continue;
                }
                Network.req(
                  `https://api.github.com/search/repositories?q=topic:${domain}+topic:userstyle`,
                  'GET',
                  'json',
                  {
                    headers: {
                      Accept: 'application/vnd.github+json',
                      Authorization: `Bearer ${engine.token}`,
                      'X-GitHub-Api-Version': '2022-11-28'
                    }
                  }
                )
                  .then(gitFN)
                  .catch(respError);
                netFN = Network.req(
                  toQuery(
                    `https://api.github.com/search/repositories?q=topic:${domain}+topic:userscript`
                  ),
                  'GET',
                  'json',
                  {
                    headers: {
                      Accept: 'application/vnd.github+json',
                      Authorization: `Bearer ${engine.token}`,
                      'X-GitHub-Api-Version': '2022-11-28'
                    }
                  }
                )
                  .then(gitFN)
                  .then(() => {
                    Network.req('https://api.github.com/rate_limit', 'GET', 'json', {
                      headers: {
                        Accept: 'application/vnd.github+json',
                        Authorization: `Bearer ${engine.token}`,
                        'X-GitHub-Api-Version': '2022-11-28'
                      }
                    })
                      .then((data) => {
                        for (const [key, value] of Object.entries(data.resources.code_search)) {
                          const txt = make('mujs-row', 'rate-info', {
                            textContent: `${key.toUpperCase()}: ${value}`
                          });
                          container.rateContainer.append(txt);
                        }
                      })
                      .catch(respError);
                  });
              } else if (/openuserjs/gi.test(engine.name)) {
                netFN = Network.req(toQuery(`${engine.url}${host}`), 'GET', 'document').then(
                  openuserjs
                );
              } else {
                netFN = Network.req(
                  toQuery(`${engine.url}/scripts/by-site/${host}.json?language=all`)
                ).then(forkFN);
              }
              if (netFN) {
                fetchRecords.push(netFN.catch(respError));
              }
            }
          } else {
            for (const ujs of hostCache) container.tabbody.append(ujs._mujs.root);
          }

          container.urlBar.placeholder = i18n$('search_placeholder');
          container.urlBar.value = '';

          if (isBlank(fetchRecords)) {
            this.sortRecords();
            return;
          }
          Promise.allSettled(fetchRecords).then(this.sortRecords).catch(showError);
        } catch (ex) {
          showError(ex);
        }
      }
      // #endregion

      sortRecords() {
        const arr = Array.from(this);
        for (const ujs of arr.flat().sort((a, b) => {
          const sortType = cfg.autoSort ?? 'daily_installs';
          return b[sortType] - a[sortType];
        })) {
          if (isElem(ujs._mujs.root)) container.tabbody.append(ujs._mujs.root);
        }
        for (const [name, value] of Object.entries(this.groupBy(arr)))
          Counter.update(value.length, { name });
      }

      groupBy() {
        return _self.groupBy(Array.from(this), ({ _mujs }) => _mujs.info.engine.name);
      }

      *[Symbol.iterator]() {
        const { host, engines } = this;
        const arr = Array.from(container).filter(
          ({ _mujs }) =>
            _mujs.info.host === host &&
            engines.find((engine) => engine.enabled && engine.name === _mujs.info.engine.name)
        );
        for (const userjs of arr) {
          yield userjs;
        }
      }
    };
    const MUList = new List();
    // #endregion
    // #region Make Config
    const makecfg = () => {
      const cbtn = make('mu-js', 'mujs-sty-flex');
      const savebtn = make('mujs-btn', 'save', {
        textContent: i18n$('save'),
        dataset: {
          command: 'save'
        },
        disabled: false
      });
      const resetbtn = make('mujs-btn', 'reset', {
        textContent: i18n$('reset'),
        dataset: {
          command: 'reset'
        }
      });
      cbtn.append(resetbtn, savebtn);

      const makesection = (name, tag) => {
        tag = tag ?? i18n$('no_license');
        name = name ?? i18n$('no_license');
        const sec = make('mujs-section', {
          dataset: {
            name: tag
          }
        });
        const lb = make('label', {
          dataset: {
            command: tag
          }
        });
        const divDesc = make('mu-js', {
          innerHTML: name
        });
        ael(sec, 'click', (evt) => {
          /** @type { HTMLElement } */
          const target = evt.target.closest('[data-command]');
          if (!target) {
            return;
          }
          const cmd = target.dataset.command;
          if (cmd === tag) {
            const a = qsA(`[data-${tag}]`, sec);
            if (dom.cl.has(a, 'hidden')) {
              dom.cl.remove(a, 'hidden');
            } else {
              dom.cl.add(a, 'hidden');
            }
          }
        });
        lb.append(divDesc);
        sec.append(lb);
        container.cfgpage.append(sec);
        if(!cfgSec.has(sec)) cfgSec.add(sec);
        return sec;
      };
      const sections = {
        general: makesection('General', 'general'),
        load: makesection('Automation', 'load'),
        list: makesection('List', 'list'),
        filters: makesection(
          `List Filters ${iconSVG.load('info', { dataset: { command: 'more-info', webpage: 'https://greasyfork.org/scripts/12179' } })}`,
          'filters'
        ),
        blacklist: makesection('Blacklist (WIP)', 'blacklist'),
        engine: makesection('Search Engines', 'engine'),
        theme: makesection('Theme Colors', 'theme'),
        exp: makesection('Import / Export', 'exp')
      };
      const makeRow = (text, value, type = 'checkbox', tag = 'general', attrs = {}) => {
        const [name, CONFIG, SUB_CONFIG] = /^(\w+)-(.+)/.exec(value) ?? [];
        const lb = make('label', 'sub-section hidden', {
          dataset: {
            [tag]: text
          }
        });
        const txt = make('mu-js', {
          innerHTML: text
        });
        lb.append(txt);
        const getDefault = () => {
          if (tag === 'engine') {
            const engine = DEFAULT_CONFIG.engines.find((engine) => engine.name === value);
            if (engine) {
              return engine;
            }
          }
          if (CONFIG) return DEFAULT_CONFIG[CONFIG][SUB_CONFIG];
          return DEFAULT_CONFIG[value];
        };
        const getValue = () => {
          if (tag === 'engine') {
            const engine = cfg.engines.find((engine) => engine.name === value);
            if (engine) {
              return engine;
            }
          }
          if (CONFIG) return cfg[CONFIG][SUB_CONFIG];
          return cfg[value];
        };
        const obj = {
          text,
          tag,
          value,
          type,
          attrs,
          default: getDefault(),
          cache: getValue()
        };
        if (type === 'select') {
          const inp = make('select', {
            dataset: {
              [tag]: text
            },
            ...attrs
          });
          for (const selV of Object.keys(template)) {
            if (selV === 'deleted' || selV === 'users') continue;
            const o = make('option', {
              value: selV,
              textContent: selV
            });
            inp.append(o);
          }
          inp.value = cfg[value];
          lb.append(inp);
          if (sections[tag]) {
            sections[tag].append(lb);
          }
          obj.elem = inp;
          cfgBase.push(obj);
          return lb;
        }
        const inp = make('input', {
          type,
          dataset: {
            [tag]: text
          },
          ...attrs
        });

        if (tag === 'engine') {
          inp.dataset.name = value;
        }

        if (sections[tag]) {
          sections[tag].append(lb);
        }

        if (type === 'checkbox') {
          const inlab = make('mu-js', 'mujs-inlab');
          const la = make('label', {
            onclick() {
              inp.dispatchEvent(new MouseEvent('click'));
            }
          });
          inlab.append(inp, la);
          lb.append(inlab);

          if (CONFIG) {
            if (CONFIG === 'filters') {
              inp.checked = cfg[CONFIG][SUB_CONFIG].enabled;
            } else {
              inp.checked = cfg[CONFIG][SUB_CONFIG];
            }
          } else {
            inp.checked = cfg[value];
          }
          ael(inp, 'change', (evt) => {
            container.unsaved = true;
            if (/filterlang/i.test(value)) {
              container.rebuild = true;
            }
            if (CONFIG) {
              if (CONFIG === 'filters') {
                cfg[CONFIG][SUB_CONFIG].enabled = evt.target.checked;
              } else {
                cfg[CONFIG][SUB_CONFIG] = evt.target.checked;
              }
            } else {
              cfg[value] = evt.target.checked;
            }
          });

          if (tag === 'engine') {
            const engine = cfg.engines.find((engine) => engine.name === value);
            if (engine) {
              inp.checked = engine.enabled;
              inp.dataset.engine = engine.name;
              ael(inp, 'change', (evt) => {
                container.unsaved = true;
                container.rebuild = true;
                engine.enabled = evt.target.checked;
                MUList.setEngines(cfg.engines);
              });

              if (engine.query) {
                const d = DEFAULT_CONFIG.engines.find((e) => e.name === engine.name);
                const urlInp = make('input', {
                  type: 'text',
                  defaultValue: '',
                  value: decode(engine.query),
                  placeholder: decode(d.query),
                  dataset: {
                    name,
                    engine: engine.name
                  },
                  onchange(evt) {
                    container.unsaved = true;
                    container.rebuild = true;
                    try {
                      engine.query = encodeURIComponent(new URL(evt.target.value).toString());
                      MUList.setEngines(cfg.engines);
                    } catch (ex) {
                      err(ex);
                    }
                  }
                });
                obj.elemUrl = urlInp;
                lb.append(urlInp);
              }
              if (engine.name === 'github') {
                const ghToken = make('input', {
                  type: 'text',
                  defaultValue: '',
                  value: engine.token ?? '',
                  placeholder: 'Paste Access Token',
                  dataset: {
                    engine: 'github-token'
                  },
                  onchange(evt) {
                    container.unsaved = true;
                    container.rebuild = true;
                    engine.token = evt.target.value;
                    MUList.setEngines(cfg.engines);
                  }
                });
                obj.elemToken = ghToken;
                lb.append(ghToken);
              }
            }
          }
        } else {
          if (type === 'text') {
            inp.defaultValue = '';
            inp.value = value ?? '';
            inp.placeholder = value ?? '';

            if (tag === 'theme') {
              inp.dataset[tag] = text;
              ael(inp, 'change', (evt) => {
                let isvalid = true;
                try {
                  const val = evt.target.value;
                  const sty = container.root.style;
                  const str = `--mujs-${text}`;
                  const prop = sty.getPropertyValue(str);
                  if (isEmpty(val)) {
                    cfg.theme[text] = DEFAULT_CONFIG.theme[text];
                    sty.removeProperty(str);
                    return;
                  }
                  if (prop === val) {
                    return;
                  }
                  sty.removeProperty(str);
                  sty.setProperty(str, val);
                  cfg.theme[text] = val;
                } catch (ex) {
                  err(ex);
                  isvalid = false;
                } finally {
                  if (isvalid) {
                    dom.cl.remove(evt.target, 'mujs-invalid');
                    dom.prop(savebtn, 'disabled', false);
                  } else {
                    dom.cl.add(evt.target, 'mujs-invalid');
                    dom.prop(savebtn, 'disabled', true);
                  }
                }
              });
            }
          }

          lb.append(inp);
        }
        obj.elem = inp;
        cfgBase.push(obj);

        return lb;
      };
      if (isGM) {
        makeRow(i18n$('userjs_sync'), 'cache');
        makeRow(i18n$('userjs_autoinject'), 'autoinject', 'checkbox', 'load');
      }
      makeRow(
        `${i18n$('redirect')} ${iconSVG.load('info', { dataset: { command: 'more-info', webpage: 'https://greasyfork.org/scripts/23840' } })}`,
        'sleazyredirect'
      );
      makeRow(`${i18n$('dtime')} (ms)`, 'time', 'number', 'general', {
        defaultValue: 10000,
        value: cfg.time,
        min: 0,
        step: 500,
        onbeforeinput(evt) {
          if (evt.target.validity.badInput) {
            dom.cl.add(evt.target, 'mujs-invalid');
            dom.prop(savebtn, 'disabled', true);
          } else {
            dom.cl.remove(evt.target, 'mujs-invalid');
            dom.prop(savebtn, 'disabled', false);
          }
        },
        oninput(evt) {
          container.unsaved = true;
          const t = evt.target;
          if (t.validity.badInput || (t.validity.rangeUnderflow && t.value !== '-1')) {
            dom.cl.add(t, 'mujs-invalid');
            dom.prop(savebtn, 'disabled', true);
          } else {
            dom.cl.remove(t, 'mujs-invalid');
            dom.prop(savebtn, 'disabled', false);
            cfg.time = isEmpty(t.value) ? cfg.time : parseFloat(t.value);
          }
        }
      });

      makeRow(i18n$('auto_fetch'), 'autofetch', 'checkbox', 'load');
      makeRow(i18n$('userjs_fullscreen'), 'autoexpand', 'checkbox', 'load', {
        onchange(e) {
          if (e.target.checked) {
            dom.cl.add([btnfullscreen, main], 'expanded');
            dom.prop(btnfullscreen, 'innerHTML', iconSVG.load('collapse'));
          } else {
            dom.cl.remove([btnfullscreen, main], 'expanded');
            dom.prop(btnfullscreen, 'innerHTML', iconSVG.load('expand'));
          }
        }
      });
      makeRow('Clear on Tab close', 'clearTabCache', 'checkbox', 'load');

      makeRow(i18n$('default_sort'), 'autoSort', 'select', 'list');
      makeRow(i18n$('filter'), 'filterlang', 'checkbox', 'list');
      makeRow(i18n$('preview_code'), 'preview-code', 'checkbox', 'list');
      makeRow(i18n$('preview_metadata'), 'preview-metadata', 'checkbox', 'list');
      makeRow(i18n$('recommend_author'), 'recommend-author', 'checkbox', 'list');
      makeRow(i18n$('recommend_other'), 'recommend-others', 'checkbox', 'list');

      for (const [k, v] of Object.entries(cfg.filters))
        makeRow(v.name, `filters-${k}`, 'checkbox', 'filters');

      makeRow('Greasy Fork', 'greasyfork', 'checkbox', 'engine');
      makeRow('Sleazy Fork', 'sleazyfork', 'checkbox', 'engine');
      makeRow('Open UserJS', 'openuserjs', 'checkbox', 'engine');
      makeRow(
        `GitHub API ${iconSVG.load('info', { dataset: { command: 'more-info', webpage: 'https://docs.github.com/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens' } })}`,
        'github',
        'checkbox',
        'engine'
      );

      for (const [k, v] of Object.entries(cfg.theme)) makeRow(k, v, 'text', 'theme');

      // const blacklist = make('textarea', {
      //   dataset: {
      //     name: 'blacklist'
      //   },
      //   rows: '10',
      //   autocomplete: false,
      //   spellcheck: false,
      //   wrap: 'soft',
      //   value: JSON.stringify(cfg.blacklist, null, ' '),
      //   oninput(evt) {
      //     let isvalid = true;
      //     try {
      //       cfg.blacklist = JSON.parse(evt.target.value);
      //       isvalid = true;
      //     } catch (ex) {
      //       err(ex);
      //       isvalid = false;
      //     } finally {
      //       if (isvalid) {
      //         dom.cl.remove(evt.target, 'mujs-invalid');
      //         dom.prop(savebtn, 'disabled', false);
      //       } else {
      //         dom.cl.add(evt.target, 'mujs-invalid');
      //         dom.prop(savebtn, 'disabled', true);
      //       }
      //     }
      //   }
      // });
      // const addList = make('mujs-add', {
      //   textContent: '+',
      //   dataset: {
      //     command: 'new-list'
      //   }
      // });
      // const n = make('input', {
      //   type: 'text',
      //   defaultValue: '',
      //   value: '',
      //   placeholder: 'Name',
      // });
      // const inpValue = make('input', {
      //   type: 'text',
      //   defaultValue: '',
      //   value: '',
      //   placeholder: 'Value',
      // });
      // const label = make('label', 'new-list hidden', {
      //   dataset: {
      //     blacklist: 'new-list'
      //   }
      // });
      // label.append(n, inpValue, addList);
      // listSec.append(label);
      // ael(addList, 'click', () => {
      //   if (isEmpty(n.value) || isEmpty(inpValue.value)) {
      //     return
      //   };
      //   createList(n.value, n.value, inpValue.value);
      // });
      const createList = (key, v = '', disabled = false, type = 'String') => {
        let txt = key;
        if (typeof key === 'string') {
          if (key.startsWith('userjs-')) {
            disabled = true;
            const s = key.substring(7);
            txt = `Built-in "${s}"`;
            v = builtinList[s];
          }
        } else if (!key.enabled) {
          return;
        }

        if (isRegExp(v)) {
          v = v.toString();
          type = 'RegExp';
        } else {
          v = JSON.stringify(v);
          type = 'Object';
        }

        const lb = make('label', 'hidden', {
          textContent: txt,
          dataset: {
            blacklist: key
          }
        });
        const inp = make('input', {
          type: 'text',
          defaultValue: '',
          value: v ?? '',
          placeholder: v ?? '',
          dataset: {
            blacklist: key
          },
          onchange(evt) {
            let isvalid = true;
            try {
              const val = evt.target.value;
              if (isEmpty(val)) {
                return;
              }
              isvalid = true;
            } catch (ex) {
              err(ex);
              isvalid = false;
            } finally {
              if (isvalid) {
                dom.cl.remove(evt.target, 'mujs-invalid');
                dom.prop(savebtn, 'disabled', false);
              } else {
                dom.cl.add(evt.target, 'mujs-invalid');
                dom.prop(savebtn, 'disabled', true);
              }
            }
          }
        });
        const selType = make('select', {
          disabled,
          dataset: {
            blacklist: key
          }
        });
        if (disabled) {
          inp.readOnly = true;
          const o = make('option', {
            value: type,
            textContent: type
          });
          selType.append(o);
        } else {
          for (const selV of ['String', 'RegExp', 'Object']) {
            const o = make('option', {
              value: selV,
              textContent: selV
            });
            selType.append(o);
          }
        }
        selType.value = type;
        lb.append(inp, selType);
        sections.blacklist.append(lb);
      };
      for (const key of cfg.blacklist) createList(key);
      const transfers = {
        export: {
          cfg: make('mujs-btn', 'mujs-export sub-section hidden', {
            textContent: i18n$('export_config'),
            dataset: {
              command: 'export-cfg',
              exp: 'export-cfg'
            }
          }),
          theme: make('mujs-btn', 'mujs-export sub-section hidden', {
            textContent: i18n$('export_theme'),
            dataset: {
              command: 'export-theme',
              exp: 'export-theme'
            }
          })
        },
        import: {
          cfg: make('mujs-btn', 'mujs-import sub-section hidden', {
            textContent: i18n$('import_config'),
            dataset: {
              command: 'import-cfg',
              exp: 'import-cfg'
            }
          }),
          theme: make('mujs-btn', 'mujs-import sub-section hidden', {
            textContent: i18n$('import_theme'),
            dataset: {
              command: 'import-theme',
              exp: 'import-theme'
            }
          })
        }
      };
      for (const value of Object.values(transfers)) {
        for (const v of Object.values(value)) {
          sections.exp.append(v);
        }
      }
      container.cfgpage.append(cbtn);
    };
    // #endregion
    container.Tabs.custom = (host) => {
      MUList.setHost(host);
      respHandles.build();
    };
    ael(mainframe, 'mouseenter', (evt) => {
      evt.preventDefault();
      evt.stopPropagation();
      if (isNull(evt.target)) return;
      evt.target.style.opacity = container.opacityMax;
      frameTimeout.clear(...frameTimeout.ids);
    });
    ael(mainframe, 'mouseleave', (evt) => {
      evt.preventDefault();
      evt.stopPropagation();
      if (isNull(evt.target)) return;
      evt.target.style.opacity = container.opacityMin;
      container.timeoutFrame();
    });
    let initClick = true;
    ael(mainframe, 'click', (evt) => {
      evt.preventDefault();
      frameTimeout.clear(...frameTimeout.ids);
      if (initClick && !cfg.autofetch) {
        initClick = false;
        respHandles.build();
      }
      dom.cl.remove(main, 'hidden');
      dom.cl.add(mainframe, 'hidden');
      if (cfg.autoexpand) {
        dom.cl.add([container.btnfullscreen, main], 'expanded');
        dom.prop(container.btnfullscreen, 'innerHTML', iconSVG.load('collapse'));
      }
    });
    ael(container.urlBar, 'input', (evt) => {
      evt.preventDefault();
      if (container.urlBar.placeholder === i18n$('newTab')) {
        return;
      }
      /**
       * @type { string }
       */
      const val = evt.target.value;
      if (isEmpty(val)) {
        dom.cl.remove([...container.toElem(), ...cfgSec], 'hidden');
        return;
      }
      const finds = new Set();
      if (!dom.cl.has(container.cfgpage, 'hidden')) {
        const reg = new RegExp(val, 'gi');
        for (const elem of cfgSec) {
          if (!isElem(elem)) continue;
          if (finds.has(elem)) continue;
          if (elem.textContent.match(reg)) finds.add(elem);
        }
        dom.cl.add(cfgSec, 'hidden');
        dom.cl.remove([...finds], 'hidden');
        return;
      }
      const cacheValues = Array.from(container).filter(({ _mujs }) => {
        return !finds.has(_mujs.root);
      });
      /**
       * @param {RegExpMatchArray} regExp
       * @param {keyof import("../typings/types.d.ts").GSForkQuery} key
       */
      const ezQuery = (regExp, key) => {
        const q_value = val.replace(regExp, '');
        const reg = new RegExp(q_value, 'gi');
        for (const v of cacheValues) {
          if (typeof k === 'number') {
            if (`${v[key]}`.match(reg)) finds.add(v._mujs.root);
          }
        }
      };
      if (val.match(/^(code_url|url):/)) {
        ezQuery(/^(code_url|url):/, 'code_url');
      } else if (val.match(/^(author|users?):/)) {
        const [, parts] = /^[\w_]+:(.+)/.exec(val) ?? [];
        if (parts) {
          const reg = new RegExp(parts, 'gi');
          for (const v of cacheValues.filter((v) => !isEmpty(v.users))) {
            for (const user of v.users) {
              for (const value of Object.values(user)) {
                if (typeof value === 'string' && value.match(reg)) {
                  finds.add(v._mujs.root);
                } else if (typeof value === 'number' && `${value}`.match(reg)) {
                  finds.add(v._mujs.root);
                }
              }
            }
          }
        }
      } else if (val.match(/^(locale|i18n):/)) {
        ezQuery(/^(locale|i18n):/, 'locale');
      } else if (val.match(/^id:/)) {
        ezQuery(/^id:/, 'id');
      } else if (val.match(/^license:/)) {
        ezQuery(/^license:/, 'license');
      } else if (val.match(/^name:/)) {
        ezQuery(/^name:/, 'name');
      } else if (val.match(/^description:/)) {
        ezQuery(/^description:/, 'description');
      } else if (val.match(/^(search_engine|engine):/)) {
        const [, parts] = /^[\w_]+:(\w+)/.exec(val) ?? [];
        if (parts) {
          const reg = new RegExp(parts, 'gi');
          for (const { _mujs } of cacheValues)
            if (_mujs.info.engine.name.match(reg)) finds.add(_mujs.root);
        }
      } else if (val.match(/^filter:/)) {
        const [, parts] = /^\w+:(.+)/.exec(val) ?? [];
        if (parts) {
          const bsFilter = loadFilters();
          const filterType = bsFilter.get(parts.trim().toLocaleLowerCase());
          if (filterType) {
            const { reg } = filterType;
            for (const { name, users, _mujs } of cacheValues) {
              if ([{ name }, ...users].find((o) => o.name.match(reg))) continue;
              finds.add(_mujs.root);
            }
          }
        }
      } else if (val.match(/^recommend:/)) {
        for (const { url, id, users, _mujs } of cacheValues) {
          if (
            users.find((u) => u.id === authorID) ||
            goodUserJS.includes(url) ||
            goodUserJS.includes(id)
          ) {
            finds.add(_mujs.root);
          }
        }
      } else {
        const reg = new RegExp(val, 'gi');
        for (const v of cacheValues) {
          if (v.name && v.name.match(reg)) finds.add(v._mujs.root);
          if (v.description && v.description.match(reg)) finds.add(v._mujs.root);
          if (v._mujs.code.data_meta)
            for (const key of Object.keys(v._mujs.code.data_meta))
              if (/name|desc/i.test(key) && key.match(reg)) finds.add(v._mujs.root);
        }
      }
      dom.cl.add(container.toElem(), 'hidden');
      dom.cl.remove([...finds], 'hidden');
    });
    ael(container.urlBar, 'change', (evt) => {
      evt.preventDefault();
      if (isNull(evt.target)) return;
      const { target } = evt;
      const tabElem = Tabs.getActive();
      if (container.urlBar.placeholder === i18n$('newTab') && tabElem) {
        const tabHost = tabElem.firstElementChild;
        const host = formatURL(normalizedHostname(target.value));
        if (Tabs.protoReg.test(target.value)) {
          const createdTab = Tabs.getTab(target.value);
          Tabs.close(tabElem);
          if (createdTab) {
            Tabs.active(createdTab);
          } else {
            Tabs.create(target.value);
          }
          target.placeholder = i18n$('search_placeholder');
          target.value = '';
        } else if (host === '*') {
          tabElem.dataset.host = host;
          tabHost.title = '<All Sites>';
          tabHost.textContent = '<All Sites>';
          MUList.setHost(host);
          respHandles.build();
        } else if (container.checkBlacklist(host)) {
          showError(`Blacklisted "${host}"`);
        } else {
          tabElem.dataset.host = host;
          tabHost.title = host;
          tabHost.textContent = host;
          MUList.setHost(host);
          respHandles.build();
        }
      }
    });
    scheduler.postTask(makecfg, { priority: 'background' });

    respHandles.build = async () => {
      await scheduler.postTask(MUList.build, { priority: 'background' });
      container.timeoutFrame();
    };

    if (cfg.autofetch) {
      respHandles.build();
    } else {
      container.timeoutFrame();
    }
  } catch (ex) {
    err(ex);
    container.remove();
  }
  return respHandles;
}
// #endregion
/**
 * @template F
 * @param { (this: F, doc: Document) => * } onDomReady
 */
const loadDOM = (onDomReady) => {
  if (isFN(onDomReady)) {
    if (document.readyState === 'interactive' || document.readyState === 'complete') {
      onDomReady(document);
    } else {
      document.addEventListener('DOMContentLoaded', (evt) => onDomReady(evt.target), {
        once: true
      });
    }
  }
};

const init = async (prefix = 'Config') => {
  const stored = await StorageSystem.getValue(prefix, DEFAULT_CONFIG);
  cfg = {
    ...DEFAULT_CONFIG,
    ...stored
  };
  info('Config:', cfg);
  loadDOM((doc) => {
    try {
      if (window.location === null)
        throw new Error('"window.location" is null, reload the webpage or use a different one', {
          cause: 'loadDOM'
        });
      if (doc === null)
        throw new Error('"doc" is null, reload the webpage or use a different one', {
          cause: 'loadDOM'
        });
      container.redirect();
      if (cfg.autoinject) {
        container.inject(primaryFN, doc);
      } else {
        container.timeoutFrame();
      }
      Command.register(i18n$('userjs_inject'), () => {
        container.inject(primaryFN, doc);
      });
      Command.register(i18n$('userjs_close'), () => {
        container.remove();
      });
    } catch (ex) {
      err(ex);
    }
  });
};
init();

})();