userscript-plus.user.js

// ==UserScript==
// @name         Magic Userscript+
// @version      7.6.8
// @description  Finds available userscripts for the current webpage.
// @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
// @license      MIT
// @downloadURL  https://update.greasyfork.org/scripts/421603/Magic%20Userscript%2B%20%3A%20Show%20Site%20All%20UserJS.user.js
// @updateURL    https://update.greasyfork.org/scripts/421603/Magic%20Userscript%2B%20%3A%20Show%20Site%20All%20UserJS.meta.js
// @icon         data:image/png;base64,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
// @match        https://*/*
// @connect      greasyfork.org
// @connect      sleazyfork.org
// @connect      github.com
// @connect      githubusercontent.com
// @connect      openuserjs.org
// @noframes
// @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
// @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 = /*css*/`mujs-root {
  --mujs-even-row: hsl(222, 14%, 22%);
  --mujs-odd-row: hsl(222, 14%, 11%);
  --mujs-even-err: hsl(0, 85%, 70%);
  --mujs-odd-err: hsl(0, 46%, 41%);
  --mujs-background-color: hsl(222, 14%, 33%);
  --mujs-gf-color: hsl(204, 82%, 54%);
  --mujs-sf-color: hsl(12, 90%, 64%);
  --mujs-border-b-color: hsla(0, 0%, 0%, 0);
  --mujs-gf-btn-color: hsl(211, 87%, 56%);
  --mujs-sf-btn-color: hsl(12, 90%, 64%);
  --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, 82%, 54%));
}
mujs-column count-frame[data-counter=sleazyfork] {
  background: var(--mujs-sf-color, hsl(12, 90%, 64%));
}
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, 79%, 66%)) !important;
}
mujs-main .mujs-footer .error:nth-child(odd) {
  background: var(--mujs-odd-err, hsl(0, 46%, 41%)) !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, 90%, 64%));
  border-color: var(--mujs-sf-btn-color, hsl(12, 90%, 64%));
}
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, 82%, 54%));
  border-color: var(--mujs-gf-color, hsl(204, 82%, 54%));
}
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, 79%, 66%)) !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, 90%, 64%));
  border-color: var(--mujs-sf-btn-color, hsl(12, 90%, 64%));
}
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, 82%, 54%));
  border-color: var(--mujs-gf-color, hsl(204, 82%, 54%));
}
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, 82%, 54%));
}
.mujs-cfg .mujs-inlab input[type=checkbox][data-name=sleazyfork]:checked + label {
  background: var(--mujs-sf-color, hsl(12, 90%, 64%));
}
.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, 90%, 64%));
  border-color: var(--mujs-sf-btn-color, hsl(12, 90%, 64%));
}
.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, 82%, 54%));
  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();

})();

/* eslint-env jquery */
/* eslint no-loop-func: 0 */
/* eslint no-undef: 0 */