☰

CookieManager

简单而强大的Cookie编辑器，允许您快速创建、编辑和删除Cookie

  1. // ==UserScript==
  2. // @name         CookieManager
  3. // @namespace    https://github.com/WhiteSevs/TamperMonkeyScript
  4. // @version      2025.8.5
  5. // @author       WhiteSevs
  6. // @description  简单而强大的Cookie编辑器，允许您快速创建、编辑和删除Cookie
  7. // @license      GPL-3.0-only
  8. // @icon         data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAA/NJREFUeF7tWm1u4jAQjVHusfR3jMQNlp5ky0l2e5K2Jym9ARLO79JzEMgyKF5FqeN5YzuwQPoHqRl/zPObN5NxVHbnf+rO/c9GAEYG3DkCYwjcOQFGETxbCGitF1mWLeq6/qGUmtZ1PW1+t0qpN2PMn0uwcTAA5vP5tKqqp8bhJ8C5R2PMCrBLajIIAFprOs3fkp0eGfFaluVSMiaFbVIAQhy3Tlw1AA3dXyjGQ0/lagFoxO091PGrZkAq5wmEq2NASuevDgCB889HXVjleb6tqmraaASbHeq6ptpgm+f5cr1eb2PDyzdenAUawfsENuXM60VRvBydQ+oCWmJljHkE1go2EQOgtSbB86q9L54FAJIubMuyfAj2DhgoAmA2m1FlR+nO+6eUWm42m9c+IwREO9YYI9ojt7fuc9HkRVF8Uv0OLPLsq+0F82T/DQDCKs8bu1rrGgDxZELh5LKdTCYfPpah88MMkGy6WdwpghL6A054mQaMx/oBaOy3F2xS2ZtNg/SsqqqocrnrUAqRhBggTF0I8MlsYjUCAiCA/skc5CYaHACO/rZq42oDzpHQ55RyXWNRgWQZ0Ef/xvFlu4sjzBShPkPjXPtzDQwGIM/zB1edzjEG2n06I7aUZgFwpS3u1dVX6LSyg83zv8DiKgSWeABczkSUut82ZJun0h4iggaSJhEGuKq20FLXWRylaKm5ABkMAN/Efb0CbjNDCSiXJlkGeOL5GwuYk/TG4xDiyYFOrGEB8NXuVtCoe0M3Pb445jbDVZs0/rRhpegX7T4nEUFJB8erTX3iyTVJulkHFU4uW6EMEN/y9KFgGdPuFQAC2HuK3JtlKgCIbtF9f8ebom12euncV3DRfFxzlkvXEAM4eiL5OMbGp+Lc3rgMAAHQIM02QmOcZMb23hr7AEDoLwEgeRgIAOstuny1A0J/GACOagJnxKYu4UTiH6E/DAAZpipUQvsHRGlqhDb1Bm3Jd8ME9wrZQsgeGbFgt9u9h765nbN/gJ6+iAGxLDhX/wCNfXuwMANoAFC0OGOcU2TJRQkjImzp2x0vAsCCIA0F7lS4ig5RTu5do28OMQAtJiA3xHbd0P4B4ru1CfrKLAgAqR6E9A8knmdZFuS8WAS7mxI2MaT9AxSDYOejAZBqgqR/wHmPtr25eYJDoD1xbI3AbbL7PFTwXOskAaAljPQBxWBt7r6yWApg2z4ZAO2Kkb4RTtnmHsLxoEJIgjSFxX6/XxwOh5+Cj6L+LdF6Z/gY8kvy5AxwgdQG46S8nc/lm/9RY5U+j/uixid6uSk5lEE1IHYjlxp/FgZcyjlk3REABKVbthkZcMuni/g2MgBB6ZZt/gJwetZfo7objAAAAABJRU5ErkJggg==
  9. // @supportURL   https://github.com/WhiteSevs/TamperMonkeyScript/issues
  10. // @match        *://*/*
  11. // @require      https://fastly.jsdelivr.net/gh/WhiteSevs/TamperMonkeyScript@86be74b83fca4fa47521cded28377b35e1d7d2ac/lib/CoverUMD/index.js
  12. // @require      https://fastly.jsdelivr.net/npm/@whitesev/utils@2.7.2/dist/index.umd.js
  13. // @require      https://fastly.jsdelivr.net/npm/@whitesev/domutils@1.5.11/dist/index.umd.js
  14. // @require      https://fastly.jsdelivr.net/npm/@whitesev/pops@2.3.0/dist/index.umd.js
  15. // @require      https://fastly.jsdelivr.net/npm/qmsg@1.4.0/dist/index.umd.js
  16. // @require      https://fastly.jsdelivr.net/gh/WhiteSevs/TamperMonkeyScript@886625af68455365e426018ecb55419dd4ea6f30/lib/CryptoJS/index.js
  17. // @connect      *
  18. // @grant        GM.cookie
  19. // @grant        GM_cookie
  20. // @grant        GM_deleteValue
  21. // @grant        GM_getValue
  22. // @grant        GM_info
  23. // @grant        GM_registerMenuCommand
  24. // @grant        GM_setValue
  25. // @grant        GM_unregisterMenuCommand
  26. // @grant        GM_xmlhttpRequest
  27. // @grant        unsafeWindow
  28. // @run-at       document-start
  29. // ==/UserScript==
  30.  
  31. (function (Qmsg, DOMUtils, Utils, pops, CryptoJS) {
  32.   'use strict';
  33.  
  34.   var _GM = /* @__PURE__ */ (() => typeof GM != "undefined" ? GM : void 0)();
  35.   var _GM_cookie = /* @__PURE__ */ (() => typeof GM_cookie != "undefined" ? GM_cookie : void 0)();
  36.   var _GM_deleteValue = /* @__PURE__ */ (() => typeof GM_deleteValue != "undefined" ? GM_deleteValue : void 0)();
  37.   var _GM_getValue = /* @__PURE__ */ (() => typeof GM_getValue != "undefined" ? GM_getValue : void 0)();
  38.   var _GM_info = /* @__PURE__ */ (() => typeof GM_info != "undefined" ? GM_info : void 0)();
  39.   var _GM_registerMenuCommand = /* @__PURE__ */ (() => typeof GM_registerMenuCommand != "undefined" ? GM_registerMenuCommand : void 0)();
  40.   var _GM_setValue = /* @__PURE__ */ (() => typeof GM_setValue != "undefined" ? GM_setValue : void 0)();
  41.   var _GM_unregisterMenuCommand = /* @__PURE__ */ (() => typeof GM_unregisterMenuCommand != "undefined" ? GM_unregisterMenuCommand : void 0)();
  42.   var _GM_xmlhttpRequest = /* @__PURE__ */ (() => typeof GM_xmlhttpRequest != "undefined" ? GM_xmlhttpRequest : void 0)();
  43.   var _unsafeWindow = /* @__PURE__ */ (() => typeof unsafeWindow != "undefined" ? unsafeWindow : void 0)();
  44.   var _monkeyWindow = /* @__PURE__ */ (() => window)();
  45.   const KEY = "GM_Panel";
  46.   const ATTRIBUTE_INIT = "data-init";
  47.   const ATTRIBUTE_KEY = "data-key";
  48.   const ATTRIBUTE_DEFAULT_VALUE = "data-default-value";
  49.   const ATTRIBUTE_INIT_MORE_VALUE = "data-init-more-value";
  50.   const PROPS_STORAGE_API = "data-storage-api";
  51.   const PanelUISize = {
  52.     /**
  53.      * 一般设置界面的尺寸
  54.      */
  55.     setting: {
  56.       get width() {
  57.         if (window.innerWidth < 550) {
  58.           return "88vw";
  59.         } else if (window.innerWidth < 700) {
  60.           return "550px";
  61.         } else {
  62.           return "700px";
  63.         }
  64.       },
  65.       get height() {
  66.         if (window.innerHeight < 450) {
  67.           return "70vh";
  68.         } else if (window.innerHeight < 550) {
  69.           return "450px";
  70.         } else {
  71.           return "550px";
  72.         }
  73.       }
  74.     },
  75.     /**
  76.      * 中等的设置界面
  77.      */
  78.     settingMiddle: {
  79.       get width() {
  80.         return window.innerWidth < 350 ? "88vw" : "350px";
  81.       },
  82.       get height() {
  83.         return window.innerHeight < 450 ? "88vh" : "450px";
  84.       }
  85.     },
  86.     /**
  87.      * 信息界面，一般用于提示信息之类
  88.      */
  89.     info: {
  90.       get width() {
  91.         return window.innerWidth < 350 ? "88vw" : "350px";
  92.       },
  93.       get height() {
  94.         return window.innerHeight < 250 ? "88vh" : "250px";
  95.       }
  96.     }
  97.   };
  98.   class StorageUtils {
  99.     /** 存储的键名 */
  100.     storageKey;
  101.     listenerData;
  102.     /**
  103.      * 存储的键名，可以是多层的，如：a.b.c
  104.      *
  105.      * 那就是
  106.      * {
  107.      *  "a": {
  108.      *     "b": {
  109.      *       "c": {
  110.      *         ...你的数据
  111.      *       }
  112.      *     }
  113.      *   }
  114.      * }
  115.      * @param key
  116.      */
  117.     constructor(key) {
  118.       if (typeof key === "string") {
  119.         let trimKey = key.trim();
  120.         if (trimKey == "") {
  121.           throw new Error("key参数不能为空字符串");
  122.         }
  123.         this.storageKey = trimKey;
  124.       } else {
  125.         throw new Error("key参数类型错误，必须是字符串");
  126.       }
  127.       this.listenerData = new Utils.Dictionary();
  128.     }
  129.     /**
  130.      * 获取本地值
  131.      */
  132.     getLocalValue() {
  133.       let localValue = _GM_getValue(this.storageKey);
  134.       if (localValue == null) {
  135.         localValue = {};
  136.         this.setLocalValue(localValue);
  137.       }
  138.       return localValue;
  139.     }
  140.     /**
  141.      * 设置本地值
  142.      * @param value
  143.      */
  144.     setLocalValue(value) {
  145.       _GM_setValue(this.storageKey, value);
  146.     }
  147.     /**
  148.      * 设置值
  149.      * @param key 键
  150.      * @param value 值
  151.      */
  152.     set(key, value) {
  153.       let oldValue = this.get(key);
  154.       let localValue = this.getLocalValue();
  155.       Reflect.set(localValue, key, value);
  156.       this.setLocalValue(localValue);
  157.       this.triggerValueChangeListener(key, oldValue, value);
  158.     }
  159.     /**
  160.      * 获取值
  161.      * @param key 键
  162.      * @param defaultValue 默认值
  163.      */
  164.     get(key, defaultValue) {
  165.       let localValue = this.getLocalValue();
  166.       return Reflect.get(localValue, key) ?? defaultValue;
  167.     }
  168.     /**
  169.      * 获取所有值
  170.      */
  171.     getAll() {
  172.       let localValue = this.getLocalValue();
  173.       return localValue;
  174.     }
  175.     /**
  176.      * 删除值
  177.      * @param key 键
  178.      */
  179.     delete(key) {
  180.       let oldValue = this.get(key);
  181.       let localValue = this.getLocalValue();
  182.       Reflect.deleteProperty(localValue, key);
  183.       this.setLocalValue(localValue);
  184.       this.triggerValueChangeListener(key, oldValue, void 0);
  185.     }
  186.     /**
  187.      * 判断是否存在该值
  188.      */
  189.     has(key) {
  190.       let localValue = this.getLocalValue();
  191.       return Reflect.has(localValue, key);
  192.     }
  193.     /**
  194.      * 获取所有键
  195.      */
  196.     keys() {
  197.       let localValue = this.getLocalValue();
  198.       return Reflect.ownKeys(localValue);
  199.     }
  200.     /**
  201.      * 获取所有值
  202.      */
  203.     values() {
  204.       let localValue = this.getLocalValue();
  205.       return Reflect.ownKeys(localValue).map(
  206.         (key) => Reflect.get(localValue, key)
  207.       );
  208.     }
  209.     /**
  210.      * 清空所有值
  211.      */
  212.     clear() {
  213.       _GM_deleteValue(this.storageKey);
  214.     }
  215.     /**
  216.      * 监听值改变
  217.      * + .set
  218.      * + .delete
  219.      * @param key 监听的键
  220.      * @param callback 值改变的回调函数
  221.      */
  222.     addValueChangeListener(key, callback) {
  223.       let listenerId = Math.random();
  224.       let listenerData = this.listenerData.get(key) || [];
  225.       listenerData.push({
  226.         id: listenerId,
  227.         key,
  228.         callback
  229.       });
  230.       this.listenerData.set(key, listenerData);
  231.       return listenerId;
  232.     }
  233.     /**
  234.      * 移除监听
  235.      * @param listenerId 监听的id或键名
  236.      */
  237.     removeValueChangeListener(listenerId) {
  238.       let flag = false;
  239.       for (const [key, listenerData] of this.listenerData.entries()) {
  240.         for (let index = 0; index < listenerData.length; index++) {
  241.           const value = listenerData[index];
  242.           if (typeof listenerId === "string" && value.key === listenerId || typeof listenerId === "number" && value.id === listenerId) {
  243.             listenerData.splice(index, 1);
  244.             index--;
  245.             flag = true;
  246.           }
  247.         }
  248.         this.listenerData.set(key, listenerData);
  249.       }
  250.       return flag;
  251.     }
  252.     /**
  253.      * 主动触发监听器
  254.      * @param key 键
  255.      * @param oldValue （可选）旧值
  256.      * @param newValue （可选）新值
  257.      */
  258.     triggerValueChangeListener(key, oldValue, newValue) {
  259.       if (!this.listenerData.has(key)) {
  260.         return;
  261.       }
  262.       let listenerData = this.listenerData.get(key);
  263.       for (let index = 0; index < listenerData.length; index++) {
  264.         const data = listenerData[index];
  265.         if (typeof data.callback === "function") {
  266.           let value = this.get(key);
  267.           let __newValue;
  268.           let __oldValue;
  269.           if (typeof oldValue !== "undefined" && arguments.length >= 2) {
  270.             __oldValue = oldValue;
  271.           } else {
  272.             __oldValue = value;
  273.           }
  274.           if (typeof newValue !== "undefined" && arguments.length > 2) {
  275.             __newValue = newValue;
  276.           } else {
  277.             __newValue = value;
  278.           }
  279.           data.callback(key, __oldValue, __newValue);
  280.         }
  281.       }
  282.     }
  283.   }
  284.   const PopsPanelStorageApi = new StorageUtils(KEY);
  285.   const PanelMenu = {
  286.     $data: {
  287.       __menuOption: [
  288.         {
  289.           key: "show_pops_panel_setting",
  290.           text: "⚙ 设置",
  291.           autoReload: false,
  292.           isStoreValue: false,
  293.           showText(text) {
  294.             return text;
  295.           },
  296.           callback: () => {
  297.             Panel.showPanel(PanelContent.getConfig(0));
  298.           }
  299.         }
  300.       ],
  301.       get menuOption() {
  302.         return this.__menuOption;
  303.       }
  304.     },
  305.     init() {
  306.       this.initExtensionsMenu();
  307.     },
  308.     /**
  309.      * 初始化菜单项
  310.      */
  311.     initExtensionsMenu() {
  312.       if (!Panel.isTopWindow()) {
  313.         return;
  314.       }
  315.       GM_Menu.add(this.$data.menuOption);
  316.     },
  317.     /**
  318.      * 添加菜单项
  319.      * @param option 菜单配置
  320.      */
  321.     addMenuOption(option) {
  322.       if (!Array.isArray(option)) {
  323.         option = [option];
  324.       }
  325.       this.$data.menuOption.push(...option);
  326.     },
  327.     /**
  328.      * 更新菜单项
  329.      * @param option 菜单配置
  330.      */
  331.     updateMenuOption(option) {
  332.       if (!Array.isArray(option)) {
  333.         option = [option];
  334.       }
  335.       option.forEach((optionItem) => {
  336.         let findIndex = this.$data.menuOption.findIndex((it) => {
  337.           return it.key === optionItem.key;
  338.         });
  339.         if (findIndex !== -1) {
  340.           this.$data.menuOption[findIndex] = optionItem;
  341.         }
  342.       });
  343.     },
  344.     /**
  345.      * 获取菜单项
  346.      * @param [index=0] 索引
  347.      */
  348.     getMenuOption(index = 0) {
  349.       return this.$data.menuOption[index];
  350.     },
  351.     /**
  352.      * 删除菜单项
  353.      * @param [index=0] 索引
  354.      */
  355.     deleteMenuOption(index = 0) {
  356.       this.$data.menuOption.splice(index, 1);
  357.     }
  358.   };
  359.   const Panel = {
  360.     /** 数据 */
  361.     $data: {
  362.       /**
  363.        * @private
  364.        */
  365.       __contentConfigInitDefaultValue: null,
  366.       /**
  367.        * @private
  368.        */
  369.       __onceExecMenuData: null,
  370.       /**
  371.        * @private
  372.        */
  373.       __onceExecData: null,
  374.       /**
  375.        * @private
  376.        */
  377.       __panelConfig: {},
  378.       $panel: null,
  379.       /**
  380.        * 菜单项初始化的默认值
  381.        */
  382.       get contentConfigInitDefaultValue() {
  383.         if (this.__contentConfigInitDefaultValue == null) {
  384.           this.__contentConfigInitDefaultValue = new utils.Dictionary();
  385.         }
  386.         return this.__contentConfigInitDefaultValue;
  387.       },
  388.       /**
  389.        * 菜单项初始化时禁用的键
  390.        */
  391.       contentConfigInitDisabledKeys: [],
  392.       /**
  393.        * 成功只执行了一次的项
  394.        */
  395.       get onceExecMenuData() {
  396.         if (this.__onceExecMenuData == null) {
  397.           this.__onceExecMenuData = new utils.Dictionary();
  398.         }
  399.         return this.__onceExecMenuData;
  400.       },
  401.       /**
  402.        * 成功只执行了一次的项
  403.        */
  404.       get onceExecData() {
  405.         if (this.__onceExecData == null) {
  406.           this.__onceExecData = new utils.Dictionary();
  407.         }
  408.         return this.__onceExecData;
  409.       },
  410.       /** 脚本名，一般用在设置的标题上 */
  411.       get scriptName() {
  412.         return SCRIPT_NAME;
  413.       },
  414.       /**
  415.        * pops.panel的默认配置
  416.        */
  417.       get panelConfig() {
  418.         return this.__panelConfig;
  419.       },
  420.       set panelConfig(value) {
  421.         this.__panelConfig = value;
  422.       },
  423.       /** 菜单项的总值在本地数据配置的键名 */
  424.       key: KEY,
  425.       /** 菜单项在attributes上配置的菜单键 */
  426.       attributeKeyName: ATTRIBUTE_KEY,
  427.       /** 菜单项在attributes上配置的菜单默认值 */
  428.       attributeDefaultValueName: ATTRIBUTE_DEFAULT_VALUE
  429.     },
  430.     init() {
  431.       this.initContentDefaultValue();
  432.       PanelMenu.init();
  433.     },
  434.     /** 判断是否是顶层窗口 */
  435.     isTopWindow() {
  436.       return _unsafeWindow.top === _unsafeWindow.self;
  437.     },
  438.     /** 初始化菜单项的默认值保存到本地数据中 */
  439.     initContentDefaultValue() {
  440.       const initDefaultValue = (config) => {
  441.         if (!config.attributes) {
  442.           return;
  443.         }
  444.         if (config.type === "button" || config.type === "forms" || config.type === "deepMenu") {
  445.           return;
  446.         }
  447.         let menuDefaultConfig = /* @__PURE__ */ new Map();
  448.         let key = config.attributes[ATTRIBUTE_KEY];
  449.         if (key != null) {
  450.           const defaultValue = config.attributes[ATTRIBUTE_DEFAULT_VALUE];
  451.           menuDefaultConfig.set(key, defaultValue);
  452.         }
  453.         let moreMenuDefaultConfig = config.attributes[ATTRIBUTE_INIT_MORE_VALUE];
  454.         if (typeof moreMenuDefaultConfig === "object" && moreMenuDefaultConfig) {
  455.           Object.keys(moreMenuDefaultConfig).forEach((key2) => {
  456.             menuDefaultConfig.set(key2, moreMenuDefaultConfig[key2]);
  457.           });
  458.         }
  459.         if (!menuDefaultConfig.size) {
  460.           log.warn(["请先配置键", config]);
  461.           return;
  462.         }
  463.         let __attr_init__ = config.attributes[ATTRIBUTE_INIT];
  464.         if (typeof __attr_init__ === "function") {
  465.           let __attr_result__ = __attr_init__();
  466.           if (typeof __attr_result__ === "boolean" && !__attr_result__) {
  467.             return;
  468.           }
  469.         }
  470.         if (config.type === "switch") {
  471.           let disabled = typeof config.disabled === "function" ? config.disabled() : config.disabled;
  472.           if (typeof disabled === "boolean" && disabled) {
  473.             this.$data.contentConfigInitDisabledKeys.push(
  474.               ...menuDefaultConfig.keys()
  475.             );
  476.           }
  477.         }
  478.         for (const [__key, __defaultValue] of menuDefaultConfig.entries()) {
  479.           this.setDefaultValue(__key, __defaultValue);
  480.         }
  481.       };
  482.       const loopInitDefaultValue = (configList) => {
  483.         for (let index = 0; index < configList.length; index++) {
  484.           let configItem = configList[index];
  485.           initDefaultValue(configItem);
  486.           let childForms = configItem.forms;
  487.           if (childForms && Array.isArray(childForms)) {
  488.             loopInitDefaultValue(childForms);
  489.           }
  490.         }
  491.       };
  492.       const contentConfigList = [...PanelContent.getAllContentConfig()];
  493.       for (let index = 0; index < contentConfigList.length; index++) {
  494.         let leftContentConfigItem = contentConfigList[index];
  495.         if (!leftContentConfigItem.forms) {
  496.           continue;
  497.         }
  498.         const rightContentConfigList = leftContentConfigItem.forms;
  499.         if (rightContentConfigList && Array.isArray(rightContentConfigList)) {
  500.           loopInitDefaultValue(rightContentConfigList);
  501.         }
  502.       }
  503.       this.$data.contentConfigInitDisabledKeys = [
  504.         ...new Set(this.$data.contentConfigInitDisabledKeys)
  505.       ];
  506.     },
  507.     /**
  508.      * 设置初始化使用的默认值
  509.      */
  510.     setDefaultValue(key, defaultValue) {
  511.       if (this.$data.contentConfigInitDefaultValue.has(key)) {
  512.         log.warn("请检查该key(已存在): " + key);
  513.       }
  514.       this.$data.contentConfigInitDefaultValue.set(key, defaultValue);
  515.     },
  516.     /**
  517.      * 设置值
  518.      * @param key 键
  519.      * @param value 值
  520.      */
  521.     setValue(key, value) {
  522.       PopsPanelStorageApi.set(key, value);
  523.     },
  524.     /**
  525.      * 获取值
  526.      * @param key 键
  527.      * @param defaultValue 默认值
  528.      */
  529.     getValue(key, defaultValue) {
  530.       let localValue = PopsPanelStorageApi.get(key);
  531.       if (localValue == null) {
  532.         if (this.$data.contentConfigInitDefaultValue.has(key)) {
  533.           return this.$data.contentConfigInitDefaultValue.get(key);
  534.         }
  535.         return defaultValue;
  536.       }
  537.       return localValue;
  538.     },
  539.     /**
  540.      * 删除值
  541.      * @param key 键
  542.      */
  543.     deleteValue(key) {
  544.       PopsPanelStorageApi.delete(key);
  545.     },
  546.     /**
  547.      * 判断该键是否存在
  548.      * @param key 键
  549.      */
  550.     hasKey(key) {
  551.       return PopsPanelStorageApi.has(key);
  552.     },
  553.     /**
  554.      * 监听调用setValue、deleteValue
  555.      * @param key 需要监听的键
  556.      * @param callback
  557.      */
  558.     addValueChangeListener(key, callback) {
  559.       let listenerId = PopsPanelStorageApi.addValueChangeListener(
  560.         key,
  561.         (__key, __newValue, __oldValue) => {
  562.           callback(key, __oldValue, __newValue);
  563.         }
  564.       );
  565.       return listenerId;
  566.     },
  567.     /**
  568.      * 移除监听
  569.      * @param listenerId 监听的id
  570.      */
  571.     removeValueChangeListener(listenerId) {
  572.       PopsPanelStorageApi.removeValueChangeListener(listenerId);
  573.     },
  574.     /**
  575.      * 主动触发菜单值改变的回调
  576.      * @param key 菜单键
  577.      * @param newValue 想要触发的新值，默认使用当前值
  578.      * @param oldValue 想要触发的旧值，默认使用当前值
  579.      */
  580.     triggerMenuValueChange(key, newValue, oldValue) {
  581.       PopsPanelStorageApi.triggerValueChangeListener(key, oldValue, newValue);
  582.     },
  583.     /**
  584.      * 移除已执行的仅执行一次的菜单
  585.      * @param key 键
  586.      */
  587.     deleteExecMenuOnce(key) {
  588.       this.$data.onceExecMenuData.delete(key);
  589.       let flag = PopsPanelStorageApi.removeValueChangeListener(key);
  590.       return flag;
  591.     },
  592.     /**
  593.      * 移除已执行的仅执行一次的菜单
  594.      * @param key 键
  595.      */
  596.     deleteOnceExec(key) {
  597.       this.$data.onceExecData.delete(key);
  598.     },
  599.     /**
  600.      * 执行菜单
  601.      *
  602.      * @param queryKey 判断的键，如果是字符串列表，那么它们的判断处理方式是与关系
  603.      * @param callback 执行的回调函数
  604.      * @param checkExec 判断是否执行回调
  605.      *
  606.      * （默认）如果想要每个菜单是`与`关系，即每个菜单都判断为开启，那么就判断它们的值&就行
  607.      *
  608.      * 如果想要任意菜单存在true再执行，那么判断它们的值|就行
  609.      *
  610.      * + 返回值都为`true`，执行回调，如果回调返回了<style>元素，该元素会在监听到值改变时被移除掉
  611.      * + 返回值有一个为`false`，则不执行回调，且移除之前回调函数返回的<style>元素
  612.      * @param once 是否只执行一次，默认true
  613.      *
  614.      * + true （默认）只执行一次，且会监听键的值改变
  615.      * + false 不会监听键的值改变
  616.      */
  617.     exec(queryKey, callback, checkExec, once = true) {
  618.       const that = this;
  619.       let queryKeyFn;
  620.       if (typeof queryKey === "string" || Array.isArray(queryKey)) {
  621.         queryKeyFn = () => queryKey;
  622.       } else {
  623.         queryKeyFn = queryKey;
  624.       }
  625.       let isArrayKey = false;
  626.       let queryKeyResult = queryKeyFn();
  627.       let keyList = [];
  628.       if (Array.isArray(queryKeyResult)) {
  629.         isArrayKey = true;
  630.         keyList = queryKeyResult;
  631.       } else {
  632.         keyList.push(queryKeyResult);
  633.       }
  634.       let findNotInDataKey = keyList.find(
  635.         (it) => !this.$data.contentConfigInitDefaultValue.has(it)
  636.       );
  637.       if (findNotInDataKey) {
  638.         log.warn(`${findNotInDataKey} 键不存在`);
  639.         return;
  640.       }
  641.       let storageKey = JSON.stringify(keyList);
  642.       if (once) {
  643.         if (this.$data.onceExecMenuData.has(storageKey)) {
  644.           return;
  645.         }
  646.         this.$data.onceExecMenuData.set(storageKey, 1);
  647.       }
  648.       let storeValueList = [];
  649.       let listenerIdList = [];
  650.       let dynamicAddStyleNodeCallback = (value, $style) => {
  651.         let dynamicResultList = [];
  652.         if (!Array.isArray($style)) {
  653.           $style = [$style];
  654.         }
  655.         $style.forEach(($styleItem) => {
  656.           if ($styleItem == null) {
  657.             return;
  658.           }
  659.           if ($styleItem instanceof HTMLStyleElement) {
  660.             dynamicResultList.push($styleItem);
  661.             return;
  662.           }
  663.         });
  664.         {
  665.           storeValueList = storeValueList.concat(dynamicResultList);
  666.         }
  667.       };
  668.       let getMenuValue = (key) => {
  669.         let value = this.getValue(key);
  670.         return value;
  671.       };
  672.       let clearBeforeStoreValue = () => {
  673.         for (let index = 0; index < storeValueList.length; index++) {
  674.           let $css = storeValueList[index];
  675.           $css.remove();
  676.           storeValueList.splice(index, 1);
  677.           index--;
  678.         }
  679.       };
  680.       let checkMenuExec = () => {
  681.         let flag = false;
  682.         if (typeof checkExec === "function") {
  683.           flag = checkExec(keyList);
  684.         } else {
  685.           flag = keyList.every((key) => getMenuValue(key));
  686.         }
  687.         return flag;
  688.       };
  689.       let valueChangeCallback = (valueOption) => {
  690.         let execFlag = checkMenuExec();
  691.         let resultList = [];
  692.         if (execFlag) {
  693.           let valueList = keyList.map((key) => this.getValue(key));
  694.           let callbackResult = callback({
  695.             value: isArrayKey ? valueList : valueList[0],
  696.             addStyleElement: (...args) => {
  697.               return dynamicAddStyleNodeCallback(true, ...args);
  698.             }
  699.           });
  700.           if (!Array.isArray(callbackResult)) {
  701.             callbackResult = [callbackResult];
  702.           }
  703.           callbackResult.forEach((it) => {
  704.             if (it == null) {
  705.               return;
  706.             }
  707.             if (it instanceof HTMLStyleElement) {
  708.               resultList.push(it);
  709.               return;
  710.             }
  711.           });
  712.         }
  713.         clearBeforeStoreValue();
  714.         storeValueList = [...resultList];
  715.       };
  716.       once && keyList.forEach((key) => {
  717.         let listenerId = this.addValueChangeListener(
  718.           key,
  719.           (key2, newValue, oldValue) => {
  720.             valueChangeCallback();
  721.           }
  722.         );
  723.         listenerIdList.push(listenerId);
  724.       });
  725.       valueChangeCallback();
  726.       let result = {
  727.         /**
  728.          * 清空菜单执行情况
  729.          *
  730.          * + 清空存储的元素列表
  731.          * + 清空值改变的监听器
  732.          * + 清空存储的一次执行的键
  733.          */
  734.         clear() {
  735.           this.clearStoreStyleElements();
  736.           this.removeValueChangeListener();
  737.           once && that.$data.onceExecMenuData.delete(storageKey);
  738.         },
  739.         /**
  740.          * 清空存储的元素列表
  741.          */
  742.         clearStoreStyleElements: () => {
  743.           return clearBeforeStoreValue();
  744.         },
  745.         /**
  746.          * 移除值改变的监听器
  747.          */
  748.         removeValueChangeListener: () => {
  749.           listenerIdList.forEach((listenerId) => {
  750.             this.removeValueChangeListener(listenerId);
  751.           });
  752.         }
  753.       };
  754.       return result;
  755.     },
  756.     /**
  757.      * 自动判断菜单是否启用，然后执行回调
  758.      * @param key 判断的键，如果是字符串列表，那么它们的判断处理方式是与关系
  759.      * @param callback 回调
  760.      * @param isReverse 逆反判断菜单启用，默认false
  761.      * @param once 是否是只执行一次，默认false
  762.      */
  763.     execMenu(key, callback, isReverse = false, once = false) {
  764.       return this.exec(
  765.         key,
  766.         (option) => {
  767.           return callback(option);
  768.         },
  769.         (keyList) => {
  770.           let execFlag = keyList.every((__key__) => {
  771.             let flag = !!this.getValue(__key__);
  772.             let disabled = Panel.$data.contentConfigInitDisabledKeys.includes(__key__);
  773.             if (disabled) {
  774.               flag = false;
  775.               log.warn(`.execMenu${once ? "Once" : ""} ${__key__} 被禁用`);
  776.             }
  777.             isReverse && (flag = !flag);
  778.             return flag;
  779.           });
  780.           return execFlag;
  781.         },
  782.         once
  783.       );
  784.     },
  785.     /**
  786.      * 自动判断菜单是否启用，然后执行回调，只会执行一次
  787.      *
  788.      * 它会自动监听值改变（设置中的修改），改变后如果未执行，则执行一次
  789.      * @param key 判断的键，如果是字符串列表，那么它们的判断处理方式是与关系
  790.      * @param callback 回调
  791.      * @param isReverse 逆反判断菜单启用，默认false
  792.      */
  793.     execMenuOnce(key, callback, isReverse = false) {
  794.       return this.execMenu(key, callback, isReverse, true);
  795.     },
  796.     /**
  797.      * 根据key执行一次
  798.      * @param key 键
  799.      * @param callback 回调
  800.      */
  801.     onceExec(key, callback) {
  802.       if (typeof key !== "string") {
  803.         throw new TypeError("key 必须是字符串");
  804.       }
  805.       if (this.$data.onceExecData.has(key)) {
  806.         return;
  807.       }
  808.       callback();
  809.       this.$data.onceExecData.set(key, 1);
  810.     },
  811.     /**
  812.      * 显示设置面板
  813.      * @param content 显示的内容配置
  814.      * @param [title] 标题
  815.      * @param [preventDefaultContentConfig=false] 是否阻止默认添加内容配置（版本号）
  816.      */
  817.     showPanel(content, title = `${SCRIPT_NAME}-设置`, preventDefaultContentConfig = false) {
  818.       let checkHasBottomVersionContentConfig = content.findIndex((it) => {
  819.         let isBottom = typeof it.isBottom === "function" ? it.isBottom() : Boolean(it.isBottom);
  820.         return isBottom && it.id === "script-version";
  821.       }) !== -1;
  822.       if (!preventDefaultContentConfig && !checkHasBottomVersionContentConfig) {
  823.         content.push(...PanelContent.getDefaultBottomContentConfig());
  824.       }
  825.       let $panel = __pops.panel({
  826.         ...{
  827.           title: {
  828.             text: title,
  829.             position: "center",
  830.             html: false,
  831.             style: ""
  832.           },
  833.           content,
  834.           btn: {
  835.             close: {
  836.               enable: true,
  837.               callback: (details, event) => {
  838.                 details.close();
  839.                 this.$data.$panel = null;
  840.               }
  841.             }
  842.           },
  843.           mask: {
  844.             enable: true,
  845.             clickEvent: {
  846.               toClose: true,
  847.               toHide: false
  848.             },
  849.             clickCallBack: (originalRun, config) => {
  850.               originalRun();
  851.               this.$data.$panel = null;
  852.             }
  853.           },
  854.           width: PanelUISize.setting.width,
  855.           height: PanelUISize.setting.height,
  856.           drag: true,
  857.           only: true
  858.         },
  859.         ...this.$data.panelConfig
  860.       });
  861.       this.$data.$panel = $panel;
  862.     }
  863.   };
  864.   const PanelSettingConfig = {
  865.     /** Toast位置 */
  866.     qmsg_config_position: {
  867.       key: "qmsg-config-position",
  868.       defaultValue: "bottom"
  869.     },
  870.     /** 最多显示的数量 */
  871.     qmsg_config_maxnums: {
  872.       key: "qmsg-config-maxnums",
  873.       defaultValue: 3
  874.     },
  875.     /** 逆序弹出 */
  876.     qmsg_config_showreverse: {
  877.       key: "qmsg-config-showreverse",
  878.       defaultValue: false
  879.     }
  880.   };
  881.   const utils = Utils.noConflict();
  882.   const domUtils = DOMUtils.noConflict();
  883.   const __pops = pops;
  884.   const log = new utils.Log(
  885.     _GM_info,
  886.     _unsafeWindow.console || _monkeyWindow.console
  887.   );
  888.   let SCRIPT_NAME = _GM_info?.script?.name || void 0;
  889.   pops.config.Utils.AnyTouch();
  890.   const DEBUG = false;
  891.   log.config({
  892.     debug: DEBUG,
  893.     logMaxCount: 1e3,
  894.     autoClearConsole: true,
  895.     tag: true
  896.   });
  897.   Qmsg.config({
  898.     isHTML: true,
  899.     autoClose: true,
  900.     showClose: false,
  901.     consoleLogContent(qmsgInst) {
  902.       const qmsgType = qmsgInst.getSetting().type;
  903.       if (qmsgType === "loading") {
  904.         return false;
  905.       }
  906.       const content = qmsgInst.getSetting().content;
  907.       if (qmsgType === "warning") {
  908.         log.warn(content);
  909.       } else if (qmsgType === "error") {
  910.         log.error(content);
  911.       } else {
  912.         log.info(content);
  913.       }
  914.       return true;
  915.     },
  916.     get position() {
  917.       return Panel.getValue(
  918.         PanelSettingConfig.qmsg_config_position.key,
  919.         PanelSettingConfig.qmsg_config_position.defaultValue
  920.       );
  921.     },
  922.     get maxNums() {
  923.       return Panel.getValue(
  924.         PanelSettingConfig.qmsg_config_maxnums.key,
  925.         PanelSettingConfig.qmsg_config_maxnums.defaultValue
  926.       );
  927.     },
  928.     get showReverse() {
  929.       return Panel.getValue(
  930.         PanelSettingConfig.qmsg_config_showreverse.key,
  931.         PanelSettingConfig.qmsg_config_showreverse.defaultValue
  932.       );
  933.     },
  934.     get zIndex() {
  935.       let maxZIndex = Utils.getMaxZIndex();
  936.       let popsMaxZIndex = pops.config.InstanceUtils.getPopsMaxZIndex().zIndex;
  937.       return Utils.getMaxValue(maxZIndex, popsMaxZIndex) + 100;
  938.     }
  939.   });
  940.   __pops.GlobalConfig.setGlobalConfig({
  941.     zIndex: () => {
  942.       let maxZIndex = Utils.getMaxZIndex(void 0, void 0, ($ele) => {
  943.         if ($ele?.classList?.contains("qmsg-shadow-container")) {
  944.           return false;
  945.         }
  946.         if ($ele?.closest("qmsg") && $ele.getRootNode() instanceof ShadowRoot) {
  947.           return false;
  948.         }
  949.       });
  950.       let popsMaxZIndex = pops.config.InstanceUtils.getPopsMaxZIndex().zIndex;
  951.       return Utils.getMaxValue(maxZIndex, popsMaxZIndex) + 100;
  952.     },
  953.     mask: {
  954.       // 开启遮罩层
  955.       enable: true,
  956.       // 取消点击遮罩层的事件
  957.       clickEvent: {
  958.         toClose: false,
  959.         toHide: false
  960.       }
  961.     },
  962.     drag: true
  963.   });
  964.   const GM_Menu = new utils.GM_Menu({
  965.     GM_getValue: _GM_getValue,
  966.     GM_setValue: _GM_setValue,
  967.     GM_registerMenuCommand: _GM_registerMenuCommand,
  968.     GM_unregisterMenuCommand: _GM_unregisterMenuCommand
  969.   });
  970.   const httpx = new utils.Httpx({
  971.     xmlHttpRequest: _GM_xmlhttpRequest,
  972.     logDetails: DEBUG
  973.   });
  974.   httpx.interceptors.request.use((data) => {
  975.     return data;
  976.   });
  977.   httpx.interceptors.response.use(void 0, (data) => {
  978.     log.error("拦截器-请求错误", data);
  979.     if (data.type === "onabort") {
  980.       Qmsg.warning("请求取消", { consoleLogContent: true });
  981.     } else if (data.type === "onerror") {
  982.       Qmsg.error("请求异常", { consoleLogContent: true });
  983.     } else if (data.type === "ontimeout") {
  984.       Qmsg.error("请求超时", { consoleLogContent: true });
  985.     } else {
  986.       Qmsg.error("其它错误", { consoleLogContent: true });
  987.     }
  988.     return data;
  989.   });
  990.   ({
  991.     Object: {
  992.       defineProperty: _unsafeWindow.Object.defineProperty
  993.     },
  994.     Function: {
  995.       apply: _unsafeWindow.Function.prototype.apply,
  996.       call: _unsafeWindow.Function.prototype.call
  997.     },
  998.     Element: {
  999.       appendChild: _unsafeWindow.Element.prototype.appendChild
  1000.     },
  1001.     setTimeout: _unsafeWindow.setTimeout
  1002.   });
  1003.   utils.addStyle.bind(utils);
  1004.   DOMUtils.selector.bind(DOMUtils);
  1005.   DOMUtils.selectorAll.bind(DOMUtils);
  1006.   const cookieManager = new utils.GM_Cookie();
  1007.   const PanelContent = {
  1008.     $data: {
  1009.       /**
  1010.        * @private
  1011.        */
  1012.       __contentConfig: null,
  1013.       get contentConfig() {
  1014.         if (this.__contentConfig == null) {
  1015.           this.__contentConfig = new utils.Dictionary();
  1016.         }
  1017.         return this.__contentConfig;
  1018.       }
  1019.     },
  1020.     /**
  1021.      * 设置所有配置项，用于初始化默认的值
  1022.      *
  1023.      * 如果是第一组添加的话，那么它默认就是设置菜单打开的配置
  1024.      * @param configList 配置项
  1025.      */
  1026.     addContentConfig(configList) {
  1027.       if (!Array.isArray(configList)) {
  1028.         configList = [configList];
  1029.       }
  1030.       let index = this.$data.contentConfig.keys().length;
  1031.       this.$data.contentConfig.set(index, configList);
  1032.     },
  1033.     /**
  1034.      * 获取所有的配置内容，用于初始化默认的值
  1035.      */
  1036.     getAllContentConfig() {
  1037.       return this.$data.contentConfig.values().flat();
  1038.     },
  1039.     /**
  1040.      * 获取配置内容
  1041.      * @param index 配置索引
  1042.      */
  1043.     getConfig(index = 0) {
  1044.       return this.$data.contentConfig.get(index) ?? [];
  1045.     },
  1046.     /**
  1047.      * 获取默认左侧底部的配置项
  1048.      */
  1049.     getDefaultBottomContentConfig() {
  1050.       return [
  1051.         {
  1052.           id: "script-version",
  1053.           title: `版本：${_GM_info?.script?.version || "未知"}`,
  1054.           isBottom: true,
  1055.           forms: [],
  1056.           clickFirstCallback(event, rightHeaderElement, rightContainerElement) {
  1057.             let supportURL = _GM_info?.script?.supportURL || _GM_info?.script?.namespace;
  1058.             if (typeof supportURL === "string" && utils.isNotNull(supportURL)) {
  1059.               window.open(supportURL, "_blank");
  1060.             }
  1061.             return false;
  1062.           }
  1063.         }
  1064.       ];
  1065.     }
  1066.   };
  1067.   let applyObjectThis = (obj) => {
  1068.     if (typeof obj === "object" && obj != null || typeof obj === "function") {
  1069.       Object.keys(obj).forEach((key) => {
  1070.         if (typeof obj[key] === "function") {
  1071.           obj[key] = obj[key].bind(obj);
  1072.         }
  1073.       });
  1074.     }
  1075.   };
  1076.   const __GM_cookie__ = _GM_cookie;
  1077.   applyObjectThis(__GM_cookie__);
  1078.   applyObjectThis(cookieManager);
  1079.   const CookieManagerApiNameList = [
  1080.     "document.cookie",
  1081.     "cookieStore",
  1082.     "GM_cookie",
  1083.     "GM.cookie"
  1084.   ];
  1085.   class CookieManagerService {
  1086.     __apiName;
  1087.     /**
  1088.      * @param apiName 强制使用Api的名称，是否使用保存的Api名称
  1089.      */
  1090.     constructor(apiName) {
  1091.       if (typeof apiName === "string") {
  1092.         if (!CookieManagerApiNameList.includes(apiName)) {
  1093.           throw new Error(`未知的apiName：${apiName}`);
  1094.         }
  1095.       }
  1096.       this.__apiName = apiName;
  1097.     }
  1098.     get cookieManagerApiName() {
  1099.       let managerApi = Panel.getValue("cookie-manager-api", "document.cookie");
  1100.       return this.__apiName || managerApi;
  1101.     }
  1102.     get cookieManager() {
  1103.       if (this.cookieManagerApiName === "GM_cookie") {
  1104.         return {
  1105.           list(options, callback) {
  1106.             __GM_cookie__.list(options, (result) => {
  1107.               callback(result);
  1108.             });
  1109.           },
  1110.           set(cookieInfo, callback) {
  1111.             __GM_cookie__.set(cookieInfo, (result) => {
  1112.               callback(result);
  1113.             });
  1114.           },
  1115.           delete(cookieInfo, callback) {
  1116.             __GM_cookie__.delete(cookieInfo, (result) => {
  1117.               callback(result);
  1118.             });
  1119.           }
  1120.         };
  1121.       } else if (this.cookieManagerApiName === "GM.cookie") {
  1122.         return {
  1123.           list(options, callback) {
  1124.             _GM.cookie.list().then((result) => {
  1125.               callback(result);
  1126.             });
  1127.           },
  1128.           set(cookieInfo, callback) {
  1129.             _GM.cookie.set(cookieInfo).then((result) => {
  1130.               callback(result ?? null);
  1131.             }).catch((reason) => {
  1132.               callback(reason);
  1133.             });
  1134.           },
  1135.           delete(cookieInfo, callback) {
  1136.             _GM.cookie.delete(cookieInfo).then((result) => {
  1137.               callback(result ?? null);
  1138.             }).catch((reason) => {
  1139.               callback(reason);
  1140.             });
  1141.           }
  1142.         };
  1143.       } else if (this.cookieManagerApiName === "cookieStore") {
  1144.         let cookieStore = _unsafeWindow.cookieStore;
  1145.         return {
  1146.           list(options, callback) {
  1147.             cookieStore.getAll().then((result) => {
  1148.               callback(result);
  1149.             }).catch((reason) => {
  1150.               log.error(reason);
  1151.               Qmsg.error(reason.toString());
  1152.             });
  1153.           },
  1154.           set(cookieInfo, callback) {
  1155.             cookieStore.set(cookieInfo).then(() => {
  1156.               callback();
  1157.             }).catch((reason) => {
  1158.               callback(reason);
  1159.             });
  1160.           },
  1161.           delete(cookieInfo, callback) {
  1162.             cookieStore.delete(cookieInfo).then((result) => {
  1163.               callback();
  1164.             }).catch((reason) => {
  1165.               callback(reason);
  1166.             });
  1167.           }
  1168.         };
  1169.       } else {
  1170.         return cookieManager;
  1171.       }
  1172.     }
  1173.     /**
  1174.      * 查询所有Cookie
  1175.      */
  1176.     queryAllCookie() {
  1177.       return new Promise((resolve, reject) => {
  1178.         try {
  1179.           this.cookieManager.list({}, (cookieListResult) => {
  1180.             let __cookieListResult__ = cookieListResult || [];
  1181.             __cookieListResult__ = __cookieListResult__.sort((a, b) => a.name.localeCompare(b.name));
  1182.             resolve(__cookieListResult__);
  1183.           });
  1184.         } catch (error) {
  1185.           log.error(error);
  1186.           Qmsg.error(error.toString());
  1187.           reject(error);
  1188.         }
  1189.       });
  1190.     }
  1191.     /**
  1192.      * 清除所有Cookie
  1193.      */
  1194.     deleteAllCookie() {
  1195.       return new Promise((resolve, reject) => {
  1196.         try {
  1197.           this.cookieManager.list({}, async (cookieListResult) => {
  1198.             const __cookieListResult__ = cookieListResult || [];
  1199.             const result = {
  1200.               success: 0,
  1201.               error: 0
  1202.             };
  1203.             for (let index = 0; index < __cookieListResult__.length; index++) {
  1204.               const cookieListItem = __cookieListResult__[index];
  1205.               let deleteError = await new Promise((deleteResolve) => {
  1206.                 this.deleteCookie(cookieListItem).then((deleteResult) => {
  1207.                   deleteResolve(deleteResult);
  1208.                 });
  1209.               });
  1210.               if (deleteError) {
  1211.                 result.error++;
  1212.               } else {
  1213.                 result.success++;
  1214.               }
  1215.             }
  1216.             resolve(result);
  1217.           });
  1218.         } catch (error) {
  1219.           log.error(error);
  1220.           Qmsg.error(error.toString());
  1221.           reject(error);
  1222.         }
  1223.       });
  1224.     }
  1225.     /**
  1226.      * 添加Cookie
  1227.      */
  1228.     addCookie(cookieInfo) {
  1229.       return new Promise((resolve, reject) => {
  1230.         try {
  1231.           Reflect.deleteProperty(cookieInfo, "hostOnly");
  1232.           this.cookieManager.set(
  1233.             cookieInfo,
  1234.             (error) => {
  1235.               if (false) ;
  1236.               resolve(error);
  1237.             }
  1238.           );
  1239.         } catch (error) {
  1240.           log.error(error);
  1241.           Qmsg.error(error.toString());
  1242.           reject(error);
  1243.         }
  1244.       });
  1245.     }
  1246.     /**
  1247.      * 删除Cookie
  1248.      */
  1249.     deleteCookie(cookieInfo) {
  1250.       return new Promise((resolve, reject) => {
  1251.         try {
  1252.           this.cookieManager.delete(
  1253.             cookieInfo,
  1254.             (error) => {
  1255.               if (false) ;
  1256.               resolve(error);
  1257.             }
  1258.           );
  1259.         } catch (error) {
  1260.           log.error(error);
  1261.           Qmsg.error(error.toString());
  1262.           reject(error);
  1263.         }
  1264.       });
  1265.     }
  1266.     /**
  1267.      * 更新Cookie
  1268.      */
  1269.     updateCookie(cookieInfo) {
  1270.       return new Promise(async (resolve, reject) => {
  1271.         let result;
  1272.         try {
  1273.           if (this.cookieManagerApiName === "document.cookie" || this.cookieManagerApiName === "cookieStore") {
  1274.             let deleteError = await this.deleteCookie(cookieInfo);
  1275.             if (deleteError) {
  1276.               throw new TypeError(deleteError.toString());
  1277.             }
  1278.           }
  1279.           let addError = await this.addCookie(cookieInfo);
  1280.           if (addError) {
  1281.             throw new TypeError(addError.toString());
  1282.           }
  1283.         } catch (error) {
  1284.           result = error;
  1285.         } finally {
  1286.           resolve(result);
  1287.         }
  1288.       });
  1289.     }
  1290.   }
  1291.   const CookieManager = new CookieManagerService();
  1292.   const PanelComponents = {
  1293.     $data: {
  1294.       __storeApiFn: null,
  1295.       get storeApiValue() {
  1296.         if (!this.__storeApiFn) {
  1297.           this.__storeApiFn = new Utils.Dictionary();
  1298.         }
  1299.         return this.__storeApiFn;
  1300.       }
  1301.     },
  1302.     /**
  1303.      * 获取自定义的存储接口
  1304.      * @param type 组件类型
  1305.      */
  1306.     getStorageApi(type) {
  1307.       if (!this.hasStorageApi(type)) {
  1308.         return;
  1309.       }
  1310.       return this.$data.storeApiValue.get(type);
  1311.     },
  1312.     /**
  1313.      * 判断是否存在自定义的存储接口
  1314.      * @param type 组件类型
  1315.      */
  1316.     hasStorageApi(type) {
  1317.       return this.$data.storeApiValue.has(type);
  1318.     },
  1319.     /**
  1320.      * 设置自定义的存储接口
  1321.      * @param type 组件类型
  1322.      * @param storageApiValue 存储接口
  1323.      */
  1324.     setStorageApi(type, storageApiValue) {
  1325.       this.$data.storeApiValue.set(type, storageApiValue);
  1326.     },
  1327.     /**
  1328.      * 初始化组件的存储接口属性
  1329.      *
  1330.      * @param type 组件类型
  1331.      * @param config 组件配置，必须包含prop属性
  1332.      * @param storageApiValue 存储接口
  1333.      */
  1334.     initComponentsStorageApi(type, config, storageApiValue) {
  1335.       let propsStorageApi;
  1336.       if (this.hasStorageApi(type)) {
  1337.         propsStorageApi = this.getStorageApi(type);
  1338.       } else {
  1339.         propsStorageApi = storageApiValue;
  1340.       }
  1341.       this.setComponentsStorageApiProperty(config, propsStorageApi);
  1342.     },
  1343.     /**
  1344.      * 设置组件的存储接口属性
  1345.      * @param config 组件配置，必须包含prop属性
  1346.      * @param storageApiValue 存储接口
  1347.      */
  1348.     setComponentsStorageApiProperty(config, storageApiValue) {
  1349.       Reflect.set(config.props, PROPS_STORAGE_API, storageApiValue);
  1350.     }
  1351.   };
  1352.   const UISwitch = function(text, key, defaultValue, clickCallBack, description, afterAddToUListCallBack, disabled, valueChangeCallBack) {
  1353.     let result = {
  1354.       text,
  1355.       type: "switch",
  1356.       description,
  1357.       disabled,
  1358.       attributes: {},
  1359.       props: {},
  1360.       getValue() {
  1361.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1362.         let value = storageApiValue.get(key, defaultValue);
  1363.         return value;
  1364.       },
  1365.       callback(event, __value) {
  1366.         let value = Boolean(__value);
  1367.         log.success(`${value ? "开启" : "关闭"} ${text}`);
  1368.         if (typeof clickCallBack === "function") {
  1369.           let result2 = clickCallBack(event, value);
  1370.           if (result2) {
  1371.             return;
  1372.           }
  1373.         }
  1374.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1375.         storageApiValue.set(key, value);
  1376.       },
  1377.       afterAddToUListCallBack
  1378.     };
  1379.     Reflect.set(result.attributes, ATTRIBUTE_KEY, key);
  1380.     Reflect.set(result.attributes, ATTRIBUTE_DEFAULT_VALUE, defaultValue);
  1381.     PanelComponents.initComponentsStorageApi(
  1382.       "switch",
  1383.       result,
  1384.       {
  1385.         get(key2, defaultValue2) {
  1386.           return Panel.getValue(key2, defaultValue2);
  1387.         },
  1388.         set(key2, value) {
  1389.           Panel.setValue(key2, value);
  1390.         }
  1391.       }
  1392.     );
  1393.     return result;
  1394.   };
  1395.   const CookieInfoTransform = {
  1396.     /**
  1397.      * 对编辑前的cookie信息进行值转换
  1398.      * @param cookieInfo
  1399.      * @param isEdit 是否是编辑
  1400.      */
  1401.     beforeEdit(cookieInfo, isEdit) {
  1402.       const cookieManagerApiName = CookieManager.cookieManagerApiName;
  1403.       if (cookieManagerApiName === "cookieStore") {
  1404.         if (typeof cookieInfo.expires === "number") {
  1405.           cookieInfo.expirationDate = cookieInfo.expires;
  1406.         }
  1407.       } else if (cookieManagerApiName === "GM_cookie" || cookieManagerApiName === "GM.cookie") {
  1408.         if (isEdit) {
  1409.           if (typeof cookieInfo.expirationDate === "number") {
  1410.             cookieInfo.expirationDate = cookieInfo.expirationDate * 1e3;
  1411.           }
  1412.         }
  1413.       }
  1414.       return cookieInfo;
  1415.     },
  1416.     /**
  1417.      * 对编辑后的cookie信息进行值转换
  1418.      * @param cookieInfo
  1419.      */
  1420.     afterEdit(cookieInfo) {
  1421.       const cookieManagerApiName = CookieManager.cookieManagerApiName;
  1422.       if (cookieManagerApiName === "document.cookie") {
  1423.         cookieInfo.domain = "";
  1424.       } else if (cookieManagerApiName === "cookieStore") {
  1425.         if (typeof cookieInfo.expirationDate === "number") {
  1426.           cookieInfo.expires = cookieInfo.expirationDate;
  1427.         }
  1428.       } else if (cookieManagerApiName === "GM_cookie" || cookieManagerApiName === "GM.cookie") {
  1429.         if (typeof cookieInfo.expirationDate === "number") {
  1430.           cookieInfo.expirationDate = Math.floor(cookieInfo.expirationDate / 1e3);
  1431.         }
  1432.       }
  1433.       return cookieInfo;
  1434.     }
  1435.   };
  1436.   let edit_ui_input = (text, getValue, setValue, disabled) => {
  1437.     let config = {
  1438.       text,
  1439.       type: "input",
  1440.       isNumber: false,
  1441.       isPassword: false,
  1442.       props: {},
  1443.       attributes: {},
  1444.       description: "",
  1445.       getValue() {
  1446.         return getValue();
  1447.       },
  1448.       callback(event, value) {
  1449.         setValue(value);
  1450.       },
  1451.       placeholder: "",
  1452.       disabled: Boolean(disabled)
  1453.     };
  1454.     return config;
  1455.   };
  1456.   let edit_ui_textarea = (text, getValue, setValue, disabled) => {
  1457.     let config = {
  1458.       text,
  1459.       type: "textarea",
  1460.       props: {},
  1461.       attributes: {},
  1462.       description: "",
  1463.       placeholder: "",
  1464.       getValue() {
  1465.         return getValue();
  1466.       },
  1467.       disabled,
  1468.       callback: function(event, value) {
  1469.         setValue(value);
  1470.       }
  1471.     };
  1472.     return config;
  1473.   };
  1474.   let edit_ui_select = (text, data, getValue, setValue, disabled) => {
  1475.     let config = {
  1476.       text,
  1477.       type: "select",
  1478.       description: "",
  1479.       attributes: {},
  1480.       props: {},
  1481.       getValue() {
  1482.         return getValue();
  1483.       },
  1484.       callback(event, isSelectedValue, isSelectedText) {
  1485.         let value = isSelectedValue;
  1486.         setValue(value);
  1487.       },
  1488.       data: typeof data === "function" ? data() : data,
  1489.       disabled: Boolean(disabled)
  1490.     };
  1491.     return config;
  1492.   };
  1493.   const CookieManagerEditView = {
  1494.     init() {
  1495.     },
  1496.     /**
  1497.      * 显示视图
  1498.      * @param cookieInfo 需要编辑的cookie，为空的话是添加
  1499.      * @param dialogCloseCallBack 弹窗关闭的回调
  1500.      */
  1501.     showView(__cookieInfo__, dialogCloseCallBack) {
  1502.       let isEdit = !!__cookieInfo__;
  1503.       let defaultCookieInfo = {
  1504.         name: "",
  1505.         value: "",
  1506.         domain: window.location.hostname,
  1507.         path: "/",
  1508.         secure: false,
  1509.         session: false,
  1510.         hostOnly: false,
  1511.         httpOnly: false,
  1512.         sameSite: "lax",
  1513.         // 一个月后过期
  1514.         // 单位：毫秒
  1515.         expirationDate: Date.now() + 60 * 60 * 24 * 30 * 1e3
  1516.       };
  1517.       let cookieInfo = utils.assign({}, defaultCookieInfo, true);
  1518.       utils.assign(cookieInfo, __cookieInfo__ ?? {}, true);
  1519.       cookieInfo = CookieInfoTransform.beforeEdit(cookieInfo, isEdit);
  1520.       let $dialog = __pops.confirm({
  1521.         title: {
  1522.           text: isEdit ? "编辑Cookie" : "添加Cookie",
  1523.           position: "center"
  1524.         },
  1525.         content: {
  1526.           text: "",
  1527.           html: true
  1528.         },
  1529.         drag: true,
  1530.         btn: {
  1531.           position: "center",
  1532.           ok: {
  1533.             text: isEdit ? "编辑" : "添加",
  1534.             async callback(eventDetails, event) {
  1535.               let valid = CookieManagerEditView.validCookieInfo(cookieInfo);
  1536.               if (!valid) {
  1537.                 return;
  1538.               }
  1539.               cookieInfo.value = encodeURIComponent(cookieInfo.value);
  1540.               cookieInfo = CookieInfoTransform.afterEdit(cookieInfo);
  1541.               if (isEdit) {
  1542.                 let result = await CookieManager.updateCookie(cookieInfo);
  1543.                 if (result) {
  1544.                   Qmsg.error(result.toString());
  1545.                 } else {
  1546.                   Qmsg.success("修改成功");
  1547.                   eventDetails.close();
  1548.                 }
  1549.               } else {
  1550.                 let result = await CookieManager.addCookie(cookieInfo);
  1551.                 if (result) {
  1552.                   Qmsg.error(result.toString());
  1553.                 } else {
  1554.                   Qmsg.success("添加成功");
  1555.                   eventDetails.close();
  1556.                 }
  1557.               }
  1558.               if (typeof dialogCloseCallBack === "function") {
  1559.                 dialogCloseCallBack(cookieInfo);
  1560.               }
  1561.             }
  1562.           },
  1563.           cancel: {
  1564.             text: "取消"
  1565.           }
  1566.         },
  1567.         mask: {
  1568.           enable: true
  1569.         },
  1570.         width: PanelUISize.settingMiddle.width,
  1571.         height: "auto",
  1572.         style: (
  1573.           /*css*/
  1574.           `
  1575.                 ${__pops.config.cssText.panelCSS}
  1576.  
  1577.                 .pops-panel-input input:disabled{
  1578.                     color: #b4b4b4;
  1579.                 }
  1580.                 .pops-confirm-content{
  1581.                     padding: 10px;
  1582.                 }
  1583.                 .pops-confirm-content li{
  1584.                     display: flex;
  1585.                     flex-direction: column;
  1586.                 }
  1587.                 .pops-panel-item-left-text{
  1588.                     margin-bottom: 5px;
  1589.                 }
  1590.                 .pops-panel-input.pops-input-disabled{
  1591.                     border: 1px solid #dcdfe6;
  1592.                 }
  1593. 				.pops-panel-textarea textarea{
  1594. 					resize: auto;
  1595. 					border-radius: 4px;
  1596. 				}
  1597. 				#cookie-item-property-expires{
  1598. 					border: 1px solid rgb(184, 184, 184, var(--pops-bd-opacity));
  1599. 					border-radius: 4px;
  1600. 					background-color: #ffffff;
  1601. 					width: 100%;
  1602. 					height: 32px;
  1603. 					padding: 0px 8px;
  1604. 				}
  1605. 				#cookie-item-property-expires:hover{
  1606. 					border: 1px solid #c0c4cc
  1607. 				}
  1608. 				#cookie-item-property-expires:focus,
  1609. 				#cookie-item-property-expires:focus-within{
  1610. 					outline: 0;
  1611. 					border: 1px solid #409eff;
  1612. 					border-radius: 4px;
  1613. 					box-shadow: none;
  1614. 				}
  1615.             `
  1616.         )
  1617.       });
  1618.       let $editContent = $dialog.$shadowRoot.querySelector(".pops-confirm-content");
  1619.       let panelHandlerComponents = __pops.config.PanelHandlerComponents();
  1620.       let $name = panelHandlerComponents.createSectionContainerItem_input(
  1621.         edit_ui_input(
  1622.           "name",
  1623.           () => cookieInfo.name,
  1624.           (value) => cookieInfo.name = value,
  1625.           isEdit
  1626.         )
  1627.       );
  1628.       let $value = panelHandlerComponents.createSectionContainerItem_textarea(
  1629.         edit_ui_textarea(
  1630.           "value",
  1631.           () => cookieInfo.value,
  1632.           (value) => cookieInfo.value = value
  1633.         )
  1634.       );
  1635.       let $domain = panelHandlerComponents.createSectionContainerItem_input(
  1636.         edit_ui_input(
  1637.           "domain",
  1638.           () => cookieInfo.domain,
  1639.           (value) => cookieInfo.domain = value
  1640.         )
  1641.       );
  1642.       let $path = panelHandlerComponents.createSectionContainerItem_input(
  1643.         edit_ui_input(
  1644.           "path",
  1645.           () => cookieInfo.path,
  1646.           (value) => cookieInfo.path = value
  1647.         )
  1648.       );
  1649.       let $expires;
  1650.       if (cookieInfo.session) {
  1651.         $expires = panelHandlerComponents.createSectionContainerItem_input(
  1652.           edit_ui_input(
  1653.             "expires",
  1654.             () => "会话",
  1655.             (value) => {
  1656.             },
  1657.             true
  1658.           )
  1659.         );
  1660.       } else {
  1661.         $expires = panelHandlerComponents.createSectionContainerItem_own({
  1662.           type: "own",
  1663.           getLiElementCallBack: function(liElement) {
  1664.             let $li = domUtils.createElement("li", {
  1665.               innerHTML: (
  1666.                 /*html*/
  1667.                 `
  1668. 							<div class="pops-panel-item-left-text">
  1669. 								<p class="pops-panel-item-left-main-text">expires</p>
  1670. 							</div>
  1671. 							<div class="pops-panel-item-right-wrapper">
  1672. 								<input type="datetime-local" id="cookie-item-property-expires">
  1673. 							</div>
  1674. 						`
  1675.               )
  1676.             });
  1677.             let $dateTime = $li.querySelector("#cookie-item-property-expires");
  1678.             $dateTime.valueAsNumber = cookieInfo.expirationDate;
  1679.             domUtils.on($dateTime, ["change", "input", "propertychange"], (event) => {
  1680.               utils.preventEvent(event);
  1681.               cookieInfo.expirationDate = $dateTime.valueAsNumber;
  1682.             });
  1683.             return $li;
  1684.           }
  1685.         });
  1686.       }
  1687.       let $httpOnly = panelHandlerComponents.createSectionContainerItem_select(
  1688.         edit_ui_select(
  1689.           "httpOnly",
  1690.           [
  1691.             {
  1692.               text: "true",
  1693.               value: true
  1694.             },
  1695.             {
  1696.               text: "false",
  1697.               value: false
  1698.             }
  1699.           ],
  1700.           () => cookieInfo.httpOnly,
  1701.           (value) => cookieInfo.httpOnly = value
  1702.         )
  1703.       );
  1704.       let $secure = panelHandlerComponents.createSectionContainerItem_select(
  1705.         edit_ui_select(
  1706.           "secure",
  1707.           [
  1708.             {
  1709.               text: "true",
  1710.               value: true
  1711.             },
  1712.             {
  1713.               text: "false",
  1714.               value: false
  1715.             }
  1716.           ],
  1717.           () => cookieInfo.secure,
  1718.           (value) => cookieInfo.secure = value
  1719.         )
  1720.       );
  1721.       let sameSiteData = [
  1722.         {
  1723.           text: "no_restriction",
  1724.           value: "no_restriction"
  1725.         },
  1726.         {
  1727.           text: "lax",
  1728.           value: "lax"
  1729.         },
  1730.         {
  1731.           text: "strict",
  1732.           value: "strict"
  1733.         },
  1734.         {
  1735.           text: "unspecified",
  1736.           value: "unspecified"
  1737.         }
  1738.       ];
  1739.       if (CookieManager.cookieManagerApiName === "cookieStore") {
  1740.         sameSiteData = [
  1741.           {
  1742.             text: "lax",
  1743.             value: "lax"
  1744.           },
  1745.           {
  1746.             text: "strict",
  1747.             value: "strict"
  1748.           },
  1749.           {
  1750.             text: "none",
  1751.             value: "none"
  1752.           }
  1753.         ];
  1754.       }
  1755.       let $sameSite = panelHandlerComponents.createSectionContainerItem_select(
  1756.         edit_ui_select(
  1757.           "sameSite",
  1758.           sameSiteData,
  1759.           () => cookieInfo.sameSite,
  1760.           (value) => cookieInfo.sameSite = value
  1761.         )
  1762.       );
  1763.       domUtils.append($editContent, [$name, $value]);
  1764.       if (CookieManager.cookieManagerApiName === "GM_cookie" || CookieManager.cookieManagerApiName === "GM.cookie") {
  1765.         domUtils.append($editContent, [$domain, $path, $expires, $httpOnly, $secure, $sameSite]);
  1766.       } else if (CookieManager.cookieManagerApiName === "cookieStore") {
  1767.         domUtils.append($editContent, [$domain, $path, $expires, $sameSite]);
  1768.       }
  1769.     },
  1770.     /**
  1771.      * Cookie信息校验
  1772.      */
  1773.     validCookieInfo(cookieInfo) {
  1774.       if (cookieInfo.name == null || cookieInfo.name == "") {
  1775.         Qmsg.error("name不能为空");
  1776.         return false;
  1777.       }
  1778.       if (cookieInfo.domain == null || cookieInfo.domain == "") {
  1779.         Qmsg.error("domain不能为空");
  1780.         return false;
  1781.       }
  1782.       if (cookieInfo.path == null || cookieInfo.path == "") {
  1783.         Qmsg.error("path不能为空");
  1784.         return false;
  1785.       }
  1786.       return true;
  1787.     }
  1788.   };
  1789.   const UISelect = function(text, key, defaultValue, data, selectCallBack, description, valueChangeCallBack) {
  1790.     let selectData = [];
  1791.     if (typeof data === "function") {
  1792.       selectData = data();
  1793.     } else {
  1794.       selectData = data;
  1795.     }
  1796.     let result = {
  1797.       text,
  1798.       type: "select",
  1799.       description,
  1800.       attributes: {},
  1801.       props: {},
  1802.       getValue() {
  1803.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1804.         return storageApiValue.get(key, defaultValue);
  1805.       },
  1806.       callback(event, isSelectedValue, isSelectedText) {
  1807.         let value = isSelectedValue;
  1808.         log.info(`选择：${isSelectedText}`);
  1809.         if (typeof selectCallBack === "function") {
  1810.           let result2 = selectCallBack(event, value, isSelectedText);
  1811.           if (result2) {
  1812.             return;
  1813.           }
  1814.         }
  1815.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1816.         storageApiValue.set(key, value);
  1817.         if (typeof valueChangeCallBack === "function") {
  1818.           valueChangeCallBack(event, value, isSelectedText);
  1819.         }
  1820.       },
  1821.       data: selectData
  1822.     };
  1823.     Reflect.set(result.attributes, ATTRIBUTE_KEY, key);
  1824.     Reflect.set(result.attributes, ATTRIBUTE_DEFAULT_VALUE, defaultValue);
  1825.     PanelComponents.initComponentsStorageApi(
  1826.       "select",
  1827.       result,
  1828.       {
  1829.         get(key2, defaultValue2) {
  1830.           return Panel.getValue(key2, defaultValue2);
  1831.         },
  1832.         set(key2, value) {
  1833.           Panel.setValue(key2, value);
  1834.         }
  1835.       }
  1836.     );
  1837.     return result;
  1838.   };
  1839.   const UIInput = function(text, key, defaultValue, description, changeCallback, placeholder = "", isNumber, isPassword, afterAddToUListCallBack, valueChangeCallback) {
  1840.     let result = {
  1841.       text,
  1842.       type: "input",
  1843.       isNumber: Boolean(isNumber),
  1844.       isPassword: Boolean(isPassword),
  1845.       attributes: {},
  1846.       props: {},
  1847.       description,
  1848.       afterAddToUListCallBack,
  1849.       getValue() {
  1850.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1851.         return storageApiValue.get(key, defaultValue);
  1852.       },
  1853.       callback(event, value, valueAsNumber) {
  1854.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1855.         storageApiValue.set(key, value);
  1856.       },
  1857.       placeholder
  1858.     };
  1859.     Reflect.set(result.attributes, ATTRIBUTE_KEY, key);
  1860.     Reflect.set(result.attributes, ATTRIBUTE_DEFAULT_VALUE, defaultValue);
  1861.     PanelComponents.initComponentsStorageApi(
  1862.       "input",
  1863.       result,
  1864.       {
  1865.         get(key2, defaultValue2) {
  1866.           return Panel.getValue(key2, defaultValue2);
  1867.         },
  1868.         set(key2, value) {
  1869.           Panel.setValue(key2, value);
  1870.         }
  1871.       }
  1872.     );
  1873.     return result;
  1874.   };
  1875.   const UITextArea = function(text, key, defaultValue, description, changeCallback, placeholder = "", disabled, valueChangeCallBack) {
  1876.     let result = {
  1877.       text,
  1878.       type: "textarea",
  1879.       attributes: {},
  1880.       props: {},
  1881.       description,
  1882.       placeholder,
  1883.       disabled,
  1884.       getValue() {
  1885.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1886.         let value = storageApiValue.get(key, defaultValue);
  1887.         if (Array.isArray(value)) {
  1888.           return value.join("\n");
  1889.         }
  1890.         return value;
  1891.       },
  1892.       callback(event, value) {
  1893.         let storageApiValue = this.props[PROPS_STORAGE_API];
  1894.         storageApiValue.set(key, value);
  1895.       }
  1896.     };
  1897.     Reflect.set(result.attributes, ATTRIBUTE_KEY, key);
  1898.     Reflect.set(result.attributes, ATTRIBUTE_DEFAULT_VALUE, defaultValue);
  1899.     PanelComponents.initComponentsStorageApi(
  1900.       "switch",
  1901.       result,
  1902.       {
  1903.         get(key2, defaultValue2) {
  1904.           return Panel.getValue(key2, defaultValue2);
  1905.         },
  1906.         set(key2, value) {
  1907.           Panel.setValue(key2, value);
  1908.         }
  1909.       }
  1910.     );
  1911.     return result;
  1912.   };
  1913.   class RuleEditView {
  1914.     option;
  1915.     constructor(option) {
  1916.       this.option = option;
  1917.     }
  1918.     /**
  1919.      * 显示视图
  1920.      */
  1921.     async showView() {
  1922.       let $dialog = __pops.confirm({
  1923.         title: {
  1924.           text: this.option.title,
  1925.           position: "center"
  1926.         },
  1927.         content: {
  1928.           text: (
  1929.             /*html*/
  1930.             `
  1931.                     <form class="rule-form-container" onsubmit="return false">
  1932.                         <ul class="rule-form-ulist"></ul>
  1933.                         <input type="submit" style="display: none;" />
  1934.                     </form>
  1935.                     `
  1936.           ),
  1937.           html: true
  1938.         },
  1939.         btn: utils.assign(
  1940.           {
  1941.             ok: {
  1942.               callback: async () => {
  1943.                 await submitSaveOption();
  1944.               }
  1945.             }
  1946.           },
  1947.           this.option.btn || {},
  1948.           true
  1949.         ),
  1950.         drag: true,
  1951.         mask: {
  1952.           enable: true
  1953.         },
  1954.         style: (
  1955.           /*css*/
  1956.           `
  1957.                 ${__pops.config.cssText.panelCSS}
  1958.                 
  1959.                 .rule-form-container {
  1960.                     
  1961.                 }
  1962.                 .rule-form-container li{
  1963.                     display: flex;
  1964.                     align-items: center;
  1965.                     justify-content: space-between;
  1966.                     padding: 5px 20px;
  1967.                     gap: 10px;
  1968.                 }
  1969. 				.rule-form-ulist-dynamic{
  1970. 					--button-margin-top: 0px;
  1971. 					--button-margin-right: 0px;
  1972. 					--button-margin-bottom: 0px;
  1973. 					--button-margin-left: 0px;
  1974. 					display: flex;
  1975. 					flex-direction: column;
  1976. 					align-items: flex-start;
  1977. 					padding: 5px 0px 5px 20px;
  1978. 				}
  1979. 				.rule-form-ulist-dynamic__inner{
  1980. 					width: 100%;
  1981. 				}
  1982. 				.rule-form-ulist-dynamic__inner-container{
  1983. 					display: flex;
  1984. 					align-items: center;
  1985. 				}
  1986. 				.dynamic-forms{
  1987. 					width: 100%;
  1988. 				}
  1989.                 .pops-panel-item-left-main-text{
  1990.                     max-width: 150px;
  1991.                 }
  1992.                 .pops-panel-item-right-text{
  1993.                     padding-left: 30px;
  1994.                 }
  1995.                 .pops-panel-item-right-text,
  1996.                 .pops-panel-item-right-main-text{
  1997.                     text-overflow: ellipsis;
  1998.                     overflow: hidden;
  1999.                     white-space: nowrap;
  2000.                 }
  2001. 				.pops-panel-item-left-desc-text{
  2002. 					line-height: normal;
  2003. 					margin-top: 6px;
  2004. 					font-size: 0.8em;
  2005. 					color: rgb(108, 108, 108);
  2006. 				}
  2007.  
  2008.                 ${this.option?.style ?? ""}
  2009.             `
  2010.         ),
  2011.         width: typeof this.option.width === "function" ? this.option.width() : window.innerWidth > 500 ? "500px" : "88vw",
  2012.         height: typeof this.option.height === "function" ? this.option.height() : window.innerHeight > 500 ? "500px" : "80vh"
  2013.       });
  2014.       let $form = $dialog.$shadowRoot.querySelector(
  2015.         ".rule-form-container"
  2016.       );
  2017.       $dialog.$shadowRoot.querySelector(
  2018.         "input[type=submit]"
  2019.       );
  2020.       let $ulist = $dialog.$shadowRoot.querySelector(".rule-form-ulist");
  2021.       let view = await this.option.getView(await this.option.data());
  2022.       $ulist.appendChild(view);
  2023.       const submitSaveOption = async () => {
  2024.         let result = await this.option.onsubmit($form, await this.option.data());
  2025.         if (!result.success) {
  2026.           return;
  2027.         }
  2028.         $dialog.close();
  2029.         await this.option.dialogCloseCallBack(true);
  2030.       };
  2031.     }
  2032.   }
  2033.   class RuleFilterView {
  2034.     option;
  2035.     constructor(option) {
  2036.       this.option = option;
  2037.     }
  2038.     showView() {
  2039.       let $alert = __pops.alert({
  2040.         title: {
  2041.           text: this.option.title,
  2042.           position: "center"
  2043.         },
  2044.         content: {
  2045.           text: (
  2046.             /*html*/
  2047.             `
  2048.                 <div class="filter-container"></div>
  2049.                 `
  2050.           )
  2051.         },
  2052.         btn: {
  2053.           ok: {
  2054.             text: "关闭",
  2055.             type: "default"
  2056.           }
  2057.         },
  2058.         drag: true,
  2059.         mask: {
  2060.           enable: true
  2061.         },
  2062.         width: window.innerWidth > 500 ? "350px" : "80vw",
  2063.         height: window.innerHeight > 500 ? "300px" : "70vh",
  2064.         style: (
  2065.           /*css*/
  2066.           `
  2067.             .filter-container{
  2068.                 height: 100%;
  2069.                 display: flex;
  2070.                 flex-direction: column;
  2071.                 gap: 20px;
  2072.             }
  2073.             .filter-container button{
  2074.                 text-wrap: wrap;
  2075.                 padding: 8px;
  2076.                 height: auto;
  2077.                 text-align: left;
  2078.             }
  2079.             `
  2080.         )
  2081.       });
  2082.       let $filterContainer = $alert.$shadowRoot.querySelector(".filter-container");
  2083.       let $fragment = document.createDocumentFragment();
  2084.       this.option.filterOption.forEach((filterOption) => {
  2085.         let $button = domUtils.createElement(
  2086.           "button",
  2087.           {
  2088.             innerText: filterOption.name
  2089.           },
  2090.           {
  2091.             type: "button"
  2092.           }
  2093.         );
  2094.         let execFilterAndCloseDialog = async () => {
  2095.           let allRuleInfo = await this.option.getAllRuleInfo();
  2096.           allRuleInfo.forEach(async (ruleInfo) => {
  2097.             let filterResult = await filterOption.filterCallBack(ruleInfo.data);
  2098.             if (!filterResult) {
  2099.               domUtils.hide(ruleInfo.$el, false);
  2100.             } else {
  2101.               domUtils.show(ruleInfo.$el, false);
  2102.             }
  2103.           });
  2104.           if (typeof this.option.execFilterCallBack === "function") {
  2105.             await this.option.execFilterCallBack();
  2106.           }
  2107.           $alert.close();
  2108.         };
  2109.         domUtils.on($button, "click", async (event) => {
  2110.           utils.preventEvent(event);
  2111.           if (typeof filterOption.callback === "function") {
  2112.             let result = await filterOption.callback(
  2113.               event,
  2114.               execFilterAndCloseDialog
  2115.             );
  2116.             if (!result) {
  2117.               return;
  2118.             }
  2119.           }
  2120.           await execFilterAndCloseDialog();
  2121.         });
  2122.         $fragment.appendChild($button);
  2123.       });
  2124.       $filterContainer.appendChild($fragment);
  2125.     }
  2126.   }
  2127.   class RuleView {
  2128.     option;
  2129.     constructor(option) {
  2130.       this.option = option;
  2131.     }
  2132.     /**
  2133.      * 显示视图
  2134.      * @param filterCallBack 返回值为false隐藏，true则不隐藏（不处理）
  2135.      */
  2136.     async showView(filterCallBack) {
  2137.       let $popsConfirm = __pops.confirm({
  2138.         title: {
  2139.           text: this.option.title,
  2140.           position: "center"
  2141.         },
  2142.         content: {
  2143.           text: (
  2144.             /*html*/
  2145.             `
  2146.                     <div class="rule-view-container">
  2147.                     </div>
  2148.                     `
  2149.           ),
  2150.           html: true
  2151.         },
  2152.         btn: {
  2153.           merge: true,
  2154.           reverse: false,
  2155.           position: "space-between",
  2156.           ok: {
  2157.             enable: this.option?.bottomControls?.add?.enable || true,
  2158.             type: "primary",
  2159.             text: "添加",
  2160.             callback: async (event) => {
  2161.               this.showEditView(
  2162.                 false,
  2163.                 await this.option.getAddData(),
  2164.                 $popsConfirm.$shadowRoot
  2165.               );
  2166.             }
  2167.           },
  2168.           close: {
  2169.             enable: true,
  2170.             callback(event) {
  2171.               $popsConfirm.close();
  2172.             }
  2173.           },
  2174.           cancel: {
  2175.             enable: this.option?.bottomControls?.filter?.enable || false,
  2176.             type: "default",
  2177.             text: "过滤",
  2178.             callback: (details, event) => {
  2179.               if (typeof this.option?.bottomControls?.filter?.callback === "function") {
  2180.                 this.option.bottomControls.filter.callback();
  2181.               }
  2182.               let getAllRuleElement = () => {
  2183.                 return Array.from(
  2184.                   $popsConfirm.$shadowRoot.querySelectorAll(
  2185.                     ".rule-view-container .rule-item"
  2186.                   )
  2187.                 );
  2188.               };
  2189.               let $button = event.target.closest(".pops-confirm-btn").querySelector(".pops-confirm-btn-cancel span");
  2190.               if (domUtils.text($button).includes("取消")) {
  2191.                 getAllRuleElement().forEach(($el) => {
  2192.                   domUtils.show($el, false);
  2193.                 });
  2194.                 domUtils.text($button, "过滤");
  2195.               } else {
  2196.                 let ruleFilterView = new RuleFilterView({
  2197.                   title: this.option.bottomControls?.filter?.title ?? "过滤规则",
  2198.                   filterOption: this.option.bottomControls?.filter?.option || [],
  2199.                   execFilterCallBack() {
  2200.                     domUtils.text($button, "取消过滤");
  2201.                   },
  2202.                   getAllRuleInfo: () => {
  2203.                     return getAllRuleElement().map(($el) => {
  2204.                       return {
  2205.                         data: this.parseRuleItemElement($el).data,
  2206.                         $el
  2207.                       };
  2208.                     });
  2209.                   }
  2210.                 });
  2211.                 ruleFilterView.showView();
  2212.               }
  2213.             }
  2214.           },
  2215.           other: {
  2216.             enable: this.option?.bottomControls?.clear?.enable || true,
  2217.             type: "xiaomi-primary",
  2218.             text: `清空所有(${(await this.option.data()).length})`,
  2219.             callback: (event) => {
  2220.               let $askDialog = __pops.confirm({
  2221.                 title: {
  2222.                   text: "提示",
  2223.                   position: "center"
  2224.                 },
  2225.                 content: {
  2226.                   text: "确定清空所有的数据？",
  2227.                   html: false
  2228.                 },
  2229.                 btn: {
  2230.                   ok: {
  2231.                     enable: true,
  2232.                     callback: async (popsEvent) => {
  2233.                       log.success("清空所有");
  2234.                       if (typeof this.option?.bottomControls?.clear?.callback === "function") {
  2235.                         this.option.bottomControls.clear.callback();
  2236.                       }
  2237.                       let data = await this.option.data();
  2238.                       if (data.length) {
  2239.                         Qmsg.error("清理失败");
  2240.                         return;
  2241.                       } else {
  2242.                         Qmsg.success("清理成功");
  2243.                       }
  2244.                       await this.updateDeleteAllBtnText($popsConfirm.$shadowRoot);
  2245.                       this.clearContent($popsConfirm.$shadowRoot);
  2246.                       $askDialog.close();
  2247.                     }
  2248.                   },
  2249.                   cancel: {
  2250.                     text: "取消",
  2251.                     enable: true
  2252.                   }
  2253.                 },
  2254.                 mask: { enable: true },
  2255.                 width: "300px",
  2256.                 height: "200px"
  2257.               });
  2258.             }
  2259.           }
  2260.         },
  2261.         mask: {
  2262.           enable: true
  2263.         },
  2264.         width: window.innerWidth > 500 ? "500px" : "88vw",
  2265.         height: window.innerHeight > 500 ? "500px" : "80vh",
  2266.         style: (
  2267.           /*css*/
  2268.           `
  2269.             ${__pops.config.cssText.panelCSS}
  2270.             
  2271.             .rule-item{
  2272.                 display: flex;
  2273.                 align-items: center;
  2274.                 line-height: normal;
  2275.                 font-size: 16px;
  2276.                 padding: 4px 8px;
  2277.                 gap: 8px;
  2278.             }
  2279.             .rule-name{
  2280.                 flex: 1;
  2281.                 white-space: nowrap;
  2282.                 text-overflow: ellipsis;
  2283.                 overflow: hidden;
  2284.             }
  2285.             .rule-controls{
  2286.                 display: flex;
  2287.                 align-items: center;
  2288.                 text-overflow: ellipsis;
  2289.                 overflow: hidden;
  2290.                 white-space: nowrap;
  2291.                 gap: 8px;
  2292.                 padding: 0px;
  2293.             }
  2294.             .rule-controls-enable{
  2295.                 
  2296.             }
  2297.             .rule-controls-edit{
  2298.                 
  2299.             }
  2300.             .rule-controls-delete{
  2301.                 
  2302.             }
  2303.             .rule-controls-edit,
  2304.             .rule-controls-delete{
  2305.                 width: 16px;
  2306.                 height: 16px;
  2307.                 cursor: pointer;
  2308.             }
  2309.             `
  2310.         )
  2311.       });
  2312.       let allData = await this.option.data();
  2313.       let changeButtonText = false;
  2314.       for (let index = 0; index < allData.length; index++) {
  2315.         let item = allData[index];
  2316.         let $ruleItemList = await this.appendRuleItemElement(
  2317.           $popsConfirm.$shadowRoot,
  2318.           item
  2319.         );
  2320.         let flag = typeof filterCallBack === "function" ? filterCallBack(item) : true;
  2321.         if (!flag) {
  2322.           changeButtonText = true;
  2323.           $ruleItemList.forEach(($el) => {
  2324.             domUtils.hide($el, false);
  2325.           });
  2326.         }
  2327.       }
  2328.       if (changeButtonText) {
  2329.         let $button = $popsConfirm.$shadowRoot.querySelector(
  2330.           ".pops-confirm-btn-cancel span"
  2331.         );
  2332.         domUtils.text($button, "取消过滤");
  2333.       }
  2334.     }
  2335.     /**
  2336.      * 显示编辑视图
  2337.      * @param isEdit 是否是编辑状态
  2338.      * @param editData 编辑的数据
  2339.      * @param $parentShadowRoot （可选）关闭弹窗后对ShadowRoot进行操作
  2340.      * @param $editRuleItemElement （可选）关闭弹窗后对规则行进行更新数据
  2341.      * @param updateDataCallBack （可选）关闭添加/编辑弹窗的回调（不更新数据）
  2342.      * @param submitCallBack （可选）添加/修改提交的回调
  2343.      */
  2344.     showEditView(isEdit, editData, $parentShadowRoot, $editRuleItemElement, updateDataCallBack, submitCallBack) {
  2345.       let dialogCloseCallBack = async (isSubmit) => {
  2346.         if (isSubmit) {
  2347.           if (typeof submitCallBack === "function") {
  2348.             let newData = await this.option.getData(editData);
  2349.             submitCallBack(newData);
  2350.           }
  2351.         } else {
  2352.           if (!isEdit) {
  2353.             await this.option.deleteData(editData);
  2354.           }
  2355.           if (typeof updateDataCallBack === "function") {
  2356.             let newData = await this.option.getData(editData);
  2357.             updateDataCallBack(newData);
  2358.           }
  2359.         }
  2360.       };
  2361.       let editView = new RuleEditView({
  2362.         title: isEdit ? "编辑" : "添加",
  2363.         data: () => {
  2364.           return editData;
  2365.         },
  2366.         dialogCloseCallBack,
  2367.         getView: async (data) => {
  2368.           return await this.option.itemControls.edit.getView(data, isEdit);
  2369.         },
  2370.         btn: {
  2371.           ok: {
  2372.             enable: true,
  2373.             text: isEdit ? "修改" : "添加"
  2374.           },
  2375.           cancel: {
  2376.             callback: async (detail, event) => {
  2377.               detail.close();
  2378.               await dialogCloseCallBack(false);
  2379.             }
  2380.           },
  2381.           close: {
  2382.             callback: async (detail, event) => {
  2383.               detail.close();
  2384.               await dialogCloseCallBack(false);
  2385.             }
  2386.           }
  2387.         },
  2388.         onsubmit: async ($form, data) => {
  2389.           let result = await this.option.itemControls.edit.onsubmit(
  2390.             $form,
  2391.             isEdit,
  2392.             data
  2393.           );
  2394.           if (result.success) {
  2395.             if (isEdit) {
  2396.               Qmsg.success("修改成功");
  2397.               $parentShadowRoot && await this.updateRuleItemElement(
  2398.                 result.data,
  2399.                 $editRuleItemElement,
  2400.                 $parentShadowRoot
  2401.               );
  2402.             } else {
  2403.               $parentShadowRoot && await this.appendRuleItemElement(
  2404.                 $parentShadowRoot,
  2405.                 result.data
  2406.               );
  2407.             }
  2408.           } else {
  2409.             if (isEdit) {
  2410.               log.error("修改失败");
  2411.             }
  2412.           }
  2413.           return result;
  2414.         },
  2415.         style: this.option.itemControls.edit.style,
  2416.         width: this.option.itemControls.edit.width,
  2417.         height: this.option.itemControls.edit.height
  2418.       });
  2419.       editView.showView();
  2420.     }
  2421.     /**
  2422.      * 解析弹窗内的各个元素
  2423.      */
  2424.     parseViewElement($shadowRoot) {
  2425.       let $container = $shadowRoot.querySelector(
  2426.         ".rule-view-container"
  2427.       );
  2428.       let $deleteBtn = $shadowRoot.querySelector(
  2429.         ".pops-confirm-btn button.pops-confirm-btn-other"
  2430.       );
  2431.       return {
  2432.         /** 容器 */
  2433.         $container,
  2434.         /** 左下角的清空按钮 */
  2435.         $deleteBtn
  2436.       };
  2437.     }
  2438.     /**
  2439.      * 解析每一项的元素
  2440.      */
  2441.     parseRuleItemElement($ruleElement) {
  2442.       let $enable = $ruleElement.querySelector(
  2443.         ".rule-controls-enable"
  2444.       );
  2445.       let $enableSwitch = $enable.querySelector(".pops-panel-switch");
  2446.       let $enableSwitchInput = $enable.querySelector(
  2447.         ".pops-panel-switch__input"
  2448.       );
  2449.       let $enableSwitchCore = $enable.querySelector(
  2450.         ".pops-panel-switch__core"
  2451.       );
  2452.       let $edit = $ruleElement.querySelector(".rule-controls-edit");
  2453.       let $delete = $ruleElement.querySelector(
  2454.         ".rule-controls-delete"
  2455.       );
  2456.       return {
  2457.         /** 启用开关 */
  2458.         $enable,
  2459.         /** 启用开关的container */
  2460.         $enableSwitch,
  2461.         /** 启用开关的input */
  2462.         $enableSwitchInput,
  2463.         /** 启用开关的core */
  2464.         $enableSwitchCore,
  2465.         /** 编辑按钮 */
  2466.         $edit,
  2467.         /** 删除按钮 */
  2468.         $delete,
  2469.         /** 存储在元素上的数据 */
  2470.         data: Reflect.get($ruleElement, "data-rule")
  2471.       };
  2472.     }
  2473.     /**
  2474.      * 创建一条规则元素
  2475.      */
  2476.     async createRuleItemElement(data, $shadowRoot) {
  2477.       let name = await this.option.getDataItemName(data);
  2478.       let $ruleItem = domUtils.createElement("div", {
  2479.         className: "rule-item",
  2480.         innerHTML: (
  2481.           /*html*/
  2482.           `
  2483. 			<div class="rule-name">${name}</div>
  2484. 			<div class="rule-controls">
  2485. 				<div class="rule-controls-enable">
  2486. 					<div class="pops-panel-switch">
  2487. 						<input class="pops-panel-switch__input" type="checkbox">
  2488. 						<span class="pops-panel-switch__core">
  2489. 							<div class="pops-panel-switch__action">
  2490. 							</div>
  2491. 						</span>
  2492. 					</div>
  2493. 				</div>
  2494. 				<div class="rule-controls-edit">
  2495. 					${__pops.config.iconSVG.edit}
  2496. 				</div>
  2497. 				<div class="rule-controls-delete">
  2498. 					${__pops.config.iconSVG.delete}
  2499. 				</div>
  2500. 			</div>
  2501. 			`
  2502.         )
  2503.       });
  2504.       Reflect.set($ruleItem, "data-rule", data);
  2505.       let switchCheckedClassName = "pops-panel-switch-is-checked";
  2506.       const {
  2507.         $enable,
  2508.         $enableSwitch,
  2509.         $enableSwitchCore,
  2510.         $enableSwitchInput,
  2511.         $delete,
  2512.         $edit
  2513.       } = this.parseRuleItemElement($ruleItem);
  2514.       if (this.option.itemControls.enable.enable) {
  2515.         domUtils.on($enableSwitchCore, "click", async (event) => {
  2516.           let isChecked = false;
  2517.           if ($enableSwitch.classList.contains(switchCheckedClassName)) {
  2518.             $enableSwitch.classList.remove(switchCheckedClassName);
  2519.             isChecked = false;
  2520.           } else {
  2521.             $enableSwitch.classList.add(switchCheckedClassName);
  2522.             isChecked = true;
  2523.           }
  2524.           $enableSwitchInput.checked = isChecked;
  2525.           await this.option.itemControls.enable.callback(data, isChecked);
  2526.         });
  2527.         if (await this.option.itemControls.enable.getEnable(data)) {
  2528.           $enableSwitch.classList.add(switchCheckedClassName);
  2529.         }
  2530.       } else {
  2531.         $enable.remove();
  2532.       }
  2533.       if (this.option.itemControls.edit.enable) {
  2534.         domUtils.on($edit, "click", (event) => {
  2535.           utils.preventEvent(event);
  2536.           this.showEditView(true, data, $shadowRoot, $ruleItem, (newData) => {
  2537.             data = null;
  2538.             data = newData;
  2539.           });
  2540.         });
  2541.       } else {
  2542.         $edit.remove();
  2543.       }
  2544.       if (this.option.itemControls.delete.enable) {
  2545.         domUtils.on($delete, "click", (event) => {
  2546.           utils.preventEvent(event);
  2547.           let $askDialog = __pops.confirm({
  2548.             title: {
  2549.               text: "提示",
  2550.               position: "center"
  2551.             },
  2552.             content: {
  2553.               text: "确定删除该条数据？",
  2554.               html: false
  2555.             },
  2556.             btn: {
  2557.               ok: {
  2558.                 enable: true,
  2559.                 callback: async (popsEvent) => {
  2560.                   log.success("删除数据");
  2561.                   let flag = await this.option.itemControls.delete.deleteCallBack(
  2562.                     data
  2563.                   );
  2564.                   if (flag) {
  2565.                     Qmsg.success("成功删除该数据");
  2566.                     $ruleItem.remove();
  2567.                     await this.updateDeleteAllBtnText($shadowRoot);
  2568.                     $askDialog.close();
  2569.                   } else {
  2570.                     Qmsg.error("删除该数据失败");
  2571.                   }
  2572.                 }
  2573.               },
  2574.               cancel: {
  2575.                 text: "取消",
  2576.                 enable: true
  2577.               }
  2578.             },
  2579.             mask: {
  2580.               enable: true
  2581.             },
  2582.             width: "300px",
  2583.             height: "200px"
  2584.           });
  2585.         });
  2586.       } else {
  2587.         $delete.remove();
  2588.       }
  2589.       return $ruleItem;
  2590.     }
  2591.     /**
  2592.      * 添加一个规则元素
  2593.      */
  2594.     async appendRuleItemElement($shadowRoot, data) {
  2595.       let { $container } = this.parseViewElement($shadowRoot);
  2596.       let $ruleItem = [];
  2597.       let iteratorData = Array.isArray(data) ? data : [data];
  2598.       for (let index = 0; index < iteratorData.length; index++) {
  2599.         let item = iteratorData[index];
  2600.         let $item = await this.createRuleItemElement(item, $shadowRoot);
  2601.         $container.appendChild($item);
  2602.         $ruleItem.push($item);
  2603.       }
  2604.       await this.updateDeleteAllBtnText($shadowRoot);
  2605.       return $ruleItem;
  2606.     }
  2607.     /**
  2608.      * 更新弹窗内容的元素
  2609.      */
  2610.     async updateRuleContaienrElement($shadowRoot) {
  2611.       this.clearContent($shadowRoot);
  2612.       const { $container } = this.parseViewElement($shadowRoot);
  2613.       let data = await this.option.data();
  2614.       await this.appendRuleItemElement($shadowRoot, data);
  2615.       await this.updateDeleteAllBtnText($shadowRoot);
  2616.     }
  2617.     /**
  2618.      * 更新规则元素
  2619.      */
  2620.     async updateRuleItemElement(data, $oldRuleItem, $shadowRoot) {
  2621.       let $newRuleItem = await this.createRuleItemElement(data, $shadowRoot);
  2622.       $oldRuleItem.after($newRuleItem);
  2623.       $oldRuleItem.remove();
  2624.     }
  2625.     /**
  2626.      * 清空内容
  2627.      */
  2628.     clearContent($shadowRoot) {
  2629.       const { $container } = this.parseViewElement($shadowRoot);
  2630.       domUtils.html($container, "");
  2631.     }
  2632.     /**
  2633.      * 设置删除按钮的文字
  2634.      */
  2635.     setDeleteBtnText($shadowRoot, text, isHTML = false) {
  2636.       const { $deleteBtn } = this.parseViewElement($shadowRoot);
  2637.       if (isHTML) {
  2638.         domUtils.html($deleteBtn, text);
  2639.       } else {
  2640.         domUtils.text($deleteBtn, text);
  2641.       }
  2642.     }
  2643.     /**
  2644.      * 更新【清空所有】的按钮的文字
  2645.      * @param $shadowRoot
  2646.      */
  2647.     async updateDeleteAllBtnText($shadowRoot) {
  2648.       let data = await this.option.data();
  2649.       this.setDeleteBtnText($shadowRoot, `清空所有(${data.length})`);
  2650.     }
  2651.   }
  2652.   const CookieRule = {
  2653.     $key: {
  2654.       STORAGE_KEY: "cookie-rule"
  2655.     },
  2656.     $data: {
  2657.       /** 匹配到的规则数据 */
  2658.       matchedRuleList: []
  2659.     },
  2660.     /** 初始化数据 */
  2661.     init() {
  2662.       this.$data.matchedRuleList = [];
  2663.       this.$data.matchedRuleList = this.getMatchedRuleList();
  2664.       if (this.$data.matchedRuleList.length) {
  2665.         GM_Menu.add({
  2666.           key: "matched-cookie-rule-list",
  2667.           text: `${window.location.hostname} ${this.$data.matchedRuleList.length}条规则`,
  2668.           isStoreValue: false,
  2669.           autoReload: false,
  2670.           showText(text, enable) {
  2671.             return text;
  2672.           },
  2673.           callback(data) {
  2674.             console.log(CookieRule.$data.matchedRuleList);
  2675.             alert(
  2676.               "以下是命中的规则名：\n" + CookieRule.$data.matchedRuleList.map((it) => it.name).join("\n")
  2677.             );
  2678.           }
  2679.         });
  2680.       }
  2681.     },
  2682.     /**
  2683.      * 获取匹配的规则
  2684.      */
  2685.     getMatchedRuleList(url = window.location.href) {
  2686.       let allData = this.getData();
  2687.       let matchedRuleList = [];
  2688.       allData.forEach((data) => {
  2689.         if (!data.enable) {
  2690.           return;
  2691.         }
  2692.         let url2 = window.location.href;
  2693.         let ruleUrl = data.data.url;
  2694.         let enableRegExpToMatchUrl = data.data.enableRegExpToMatchUrl;
  2695.         if (enableRegExpToMatchUrl) {
  2696.           let regExpUrl = new RegExp(ruleUrl, "i");
  2697.           if (!regExpUrl.test(url2)) {
  2698.             return;
  2699.           }
  2700.         } else {
  2701.           if (!url2.includes(ruleUrl)) {
  2702.             return;
  2703.           }
  2704.         }
  2705.         matchedRuleList.push(data);
  2706.       });
  2707.       return matchedRuleList;
  2708.     },
  2709.     /**
  2710.      * 显示视图
  2711.      */
  2712.     showView() {
  2713.       let panelHandlerComponents = __pops.config.PanelHandlerComponents();
  2714.       function generateStorageApi(data, handler) {
  2715.         return {
  2716.           get(key, defaultValue) {
  2717.             return Reflect.get(data, key) ?? defaultValue;
  2718.           },
  2719.           set(key, value) {
  2720.             Reflect.set(data, key, value);
  2721.           }
  2722.         };
  2723.       }
  2724.       const matchedRuleList = this.getMatchedRuleList();
  2725.       let ruleView = new RuleView({
  2726.         title: "Cookie规则",
  2727.         data: () => {
  2728.           return this.getData();
  2729.         },
  2730.         getAddData: () => {
  2731.           return this.getTemplateData();
  2732.         },
  2733.         getDataItemName: (data) => {
  2734.           return data["name"];
  2735.         },
  2736.         updateData: (data) => {
  2737.           return this.updateData(data);
  2738.         },
  2739.         deleteData: (data) => {
  2740.           return this.deleteData(data);
  2741.         },
  2742.         getData: (data) => {
  2743.           let allData = this.getData();
  2744.           let findValue = allData.find((item) => item.uuid === data.uuid);
  2745.           return findValue ?? data;
  2746.         },
  2747.         itemControls: {
  2748.           enable: {
  2749.             enable: true,
  2750.             getEnable(data) {
  2751.               return data.enable;
  2752.             },
  2753.             callback: (data, enable) => {
  2754.               data.enable = enable;
  2755.               this.updateData(data);
  2756.             }
  2757.           },
  2758.           edit: {
  2759.             enable: true,
  2760.             getView: (data, isEdit) => {
  2761.               let $fragment = document.createDocumentFragment();
  2762.               let templateData = this.getTemplateData();
  2763.               if (!isEdit) {
  2764.                 data = templateData;
  2765.               }
  2766.               let enable_template = UISwitch(
  2767.                 "启用",
  2768.                 "enable",
  2769.                 templateData.enable
  2770.               );
  2771.               Reflect.set(
  2772.                 enable_template.props,
  2773.                 PROPS_STORAGE_API,
  2774.                 generateStorageApi(data)
  2775.               );
  2776.               let $enable = panelHandlerComponents.createSectionContainerItem_switch(
  2777.                 enable_template
  2778.               );
  2779.               let name_template = UIInput(
  2780.                 "规则名称",
  2781.                 "name",
  2782.                 "",
  2783.                 templateData.name,
  2784.                 void 0,
  2785.                 "必填"
  2786.               );
  2787.               Reflect.set(
  2788.                 name_template.props,
  2789.                 PROPS_STORAGE_API,
  2790.                 generateStorageApi(data)
  2791.               );
  2792.               let $name = panelHandlerComponents.createSectionContainerItem_input(
  2793.                 name_template
  2794.               );
  2795.               let apiName_template = UISelect(
  2796.                 "Cookie管理Api",
  2797.                 "execApiName",
  2798.                 templateData.data.execApiName,
  2799.                 [
  2800.                   {
  2801.                     text: "（当前）" + CookieManager.cookieManagerApiName,
  2802.                     value: "use-global"
  2803.                   },
  2804.                   ...CookieManagerApiNameList.map((it) => {
  2805.                     return {
  2806.                       text: it,
  2807.                       value: it
  2808.                     };
  2809.                   })
  2810.                 ],
  2811.                 void 0,
  2812.                 "操作Cookie的Api函数"
  2813.               );
  2814.               Reflect.set(
  2815.                 apiName_template.props,
  2816.                 PROPS_STORAGE_API,
  2817.                 generateStorageApi(data.data)
  2818.               );
  2819.               let $apiName = panelHandlerComponents.createSectionContainerItem_select(
  2820.                 apiName_template
  2821.               );
  2822.               let url_template = UIInput(
  2823.                 "网址",
  2824.                 "url",
  2825.                 templateData.data.url,
  2826.                 "用于执行该规则的网址",
  2827.                 void 0,
  2828.                 "必填"
  2829.               );
  2830.               Reflect.set(
  2831.                 url_template.props,
  2832.                 PROPS_STORAGE_API,
  2833.                 generateStorageApi(data.data)
  2834.               );
  2835.               let $url = panelHandlerComponents.createSectionContainerItem_input(
  2836.                 url_template
  2837.               );
  2838.               let enableRegExpToMatchUrl_template = UISwitch(
  2839.                 "启用正则匹配网址",
  2840.                 "enableRegExpToMatchUrl",
  2841.                 templateData.data.enableRegExpToMatchUrl
  2842.               );
  2843.               Reflect.set(
  2844.                 enableRegExpToMatchUrl_template.props,
  2845.                 PROPS_STORAGE_API,
  2846.                 generateStorageApi(data.data)
  2847.               );
  2848.               let $enableRegExpToMatchUrl = panelHandlerComponents.createSectionContainerItem_switch(
  2849.                 enableRegExpToMatchUrl_template
  2850.               );
  2851.               let cookieName_template = UIInput(
  2852.                 "Cookie名称",
  2853.                 "cookieName",
  2854.                 templateData.data.cookieName,
  2855.                 "用于匹配执行操作的Cookie名",
  2856.                 void 0,
  2857.                 "必填"
  2858.               );
  2859.               Reflect.set(
  2860.                 cookieName_template.props,
  2861.                 PROPS_STORAGE_API,
  2862.                 generateStorageApi(data.data)
  2863.               );
  2864.               let $cookieName = panelHandlerComponents.createSectionContainerItem_input(
  2865.                 cookieName_template
  2866.               );
  2867.               let enableRegExpToMatchCookieName_template = UISwitch(
  2868.                 "启用正则匹配Cookie名称",
  2869.                 "enableRegExpToMatchCookieName",
  2870.                 templateData.data.enableRegExpToMatchCookieName
  2871.               );
  2872.               Reflect.set(
  2873.                 enableRegExpToMatchCookieName_template.props,
  2874.                 PROPS_STORAGE_API,
  2875.                 generateStorageApi(data.data)
  2876.               );
  2877.               let $enableRegExpToMatchCookieName = panelHandlerComponents.createSectionContainerItem_switch(
  2878.                 enableRegExpToMatchCookieName_template
  2879.               );
  2880.               let operationMode_template = UISelect(
  2881.                 "操作模式",
  2882.                 "operationMode",
  2883.                 templateData.data.operationMode,
  2884.                 [
  2885.                   {
  2886.                     value: "delete",
  2887.                     text: "删除Cookie"
  2888.                   },
  2889.                   {
  2890.                     value: "extended",
  2891.                     text: "自动延长Cookie有效期30天"
  2892.                   },
  2893.                   {
  2894.                     value: "extended-90",
  2895.                     text: "自动延长Cookie有效期90天"
  2896.                   },
  2897.                   {
  2898.                     value: "extended-180",
  2899.                     text: "自动延长Cookie有效期180天"
  2900.                   },
  2901.                   {
  2902.                     value: "extended-360",
  2903.                     text: "自动延长Cookie有效期360天"
  2904.                   }
  2905.                 ]
  2906.               );
  2907.               Reflect.set(
  2908.                 operationMode_template.props,
  2909.                 PROPS_STORAGE_API,
  2910.                 generateStorageApi(data.data)
  2911.               );
  2912.               let $operationMode = panelHandlerComponents.createSectionContainerItem_select(
  2913.                 operationMode_template
  2914.               );
  2915.               let remark_template = UITextArea(
  2916.                 "备注",
  2917.                 "remark",
  2918.                 templateData.data.remark
  2919.               );
  2920.               Reflect.set(
  2921.                 remark_template.props,
  2922.                 PROPS_STORAGE_API,
  2923.                 generateStorageApi(data.data)
  2924.               );
  2925.               let $remark = panelHandlerComponents.createSectionContainerItem_textarea(
  2926.                 remark_template
  2927.               );
  2928.               $fragment.append(
  2929.                 $enable,
  2930.                 $name,
  2931.                 $apiName,
  2932.                 $url,
  2933.                 $enableRegExpToMatchUrl,
  2934.                 $cookieName,
  2935.                 $enableRegExpToMatchCookieName,
  2936.                 $operationMode,
  2937.                 $remark
  2938.               );
  2939.               return $fragment;
  2940.             },
  2941.             onsubmit: ($form, isEdit, editData) => {
  2942.               let $ulist_li = $form.querySelectorAll(
  2943.                 ".rule-form-ulist > li"
  2944.               );
  2945.               let data = this.getTemplateData();
  2946.               if (isEdit) {
  2947.                 data.uuid = editData.uuid;
  2948.               }
  2949.               try {
  2950.                 $ulist_li.forEach(($li) => {
  2951.                   let formConfig = Reflect.get($li, "__formConfig__");
  2952.                   let attrs = Reflect.get(formConfig, "attributes");
  2953.                   let storageApi = Reflect.get($li, PROPS_STORAGE_API);
  2954.                   let key = Reflect.get(attrs, ATTRIBUTE_KEY);
  2955.                   let defaultValue = Reflect.get(attrs, ATTRIBUTE_DEFAULT_VALUE);
  2956.                   let value = storageApi.get(key, defaultValue);
  2957.                   if (Reflect.has(data, key)) {
  2958.                     Reflect.set(data, key, value);
  2959.                   } else if (Reflect.has(data.data, key)) {
  2960.                     Reflect.set(data.data, key, value);
  2961.                   } else {
  2962.                     log.error(`${key}不在数据中`);
  2963.                   }
  2964.                 });
  2965.                 if (data.name.trim() === "") {
  2966.                   Qmsg.error("规则名称不能为空");
  2967.                   return {
  2968.                     success: false,
  2969.                     data
  2970.                   };
  2971.                 }
  2972.                 if (data.data.url.trim() === "") {
  2973.                   Qmsg.error("网址不能为空");
  2974.                   return {
  2975.                     success: false,
  2976.                     data
  2977.                   };
  2978.                 }
  2979.                 if (data.data.cookieName.trim() === "") {
  2980.                   Qmsg.error("Cookie名称不能为空");
  2981.                   return {
  2982.                     success: false,
  2983.                     data
  2984.                   };
  2985.                 }
  2986.                 if (isEdit) {
  2987.                   return {
  2988.                     success: this.updateData(data),
  2989.                     data
  2990.                   };
  2991.                 } else {
  2992.                   return {
  2993.                     success: this.addData(data),
  2994.                     data
  2995.                   };
  2996.                 }
  2997.               } catch (error) {
  2998.                 log.error(error);
  2999.                 return {
  3000.                   success: false,
  3001.                   data
  3002.                 };
  3003.               } finally {
  3004.                 this.init();
  3005.               }
  3006.             },
  3007.             style: (
  3008.               /*css*/
  3009.               `
  3010.                     .pops-panel-textarea textarea{
  3011.                         height: 150px;
  3012.                     }
  3013. 					.pops-panel-item-left-desc-text{
  3014. 						line-height: normal;
  3015. 						margin-top: 6px;
  3016. 						font-size: 0.8em;
  3017. 						color: rgb(108, 108, 108);
  3018. 						max-width: 100px;
  3019. 					}
  3020.                     `
  3021.             )
  3022.           },
  3023.           delete: {
  3024.             enable: true,
  3025.             deleteCallBack: (data) => {
  3026.               return this.deleteData(data);
  3027.             }
  3028.           }
  3029.         },
  3030.         bottomControls: {
  3031.           filter: {
  3032.             enable: true,
  3033.             option: [
  3034.               {
  3035.                 name: "过滤-已启用",
  3036.                 filterCallBack(data) {
  3037.                   return data.enable;
  3038.                 }
  3039.               },
  3040.               {
  3041.                 name: "过滤-未启用",
  3042.                 filterCallBack(data) {
  3043.                   return !data.enable;
  3044.                 }
  3045.               },
  3046.               {
  3047.                 name: "过滤-当前网站执行",
  3048.                 filterCallBack(data) {
  3049.                   return matchedRuleList.some((it) => it.uuid === data.uuid);
  3050.                 }
  3051.               }
  3052.             ]
  3053.           }
  3054.         }
  3055.       });
  3056.       ruleView.showView();
  3057.     },
  3058.     /**
  3059.      * 获取模板数据
  3060.      */
  3061.     getTemplateData() {
  3062.       return {
  3063.         uuid: utils.generateUUID(),
  3064.         enable: true,
  3065.         name: "",
  3066.         data: {
  3067.           url: "",
  3068.           execApiName: "use-global",
  3069.           enableRegExpToMatchUrl: false,
  3070.           cookieName: "",
  3071.           enableRegExpToMatchCookieName: false,
  3072.           operationMode: "delete",
  3073.           remark: ""
  3074.         }
  3075.       };
  3076.     },
  3077.     /**
  3078.      * 获取数据
  3079.      */
  3080.     getData() {
  3081.       return _GM_getValue(this.$key.STORAGE_KEY, []);
  3082.     },
  3083.     /**
  3084.      * 设置数据
  3085.      * @param data
  3086.      */
  3087.     setData(data) {
  3088.       _GM_setValue(this.$key.STORAGE_KEY, data);
  3089.     },
  3090.     /**
  3091.      * 添加数据
  3092.      * @param data
  3093.      */
  3094.     addData(data) {
  3095.       let localData = this.getData();
  3096.       let findIndex = localData.findIndex((item) => item.uuid == data.uuid);
  3097.       if (findIndex === -1) {
  3098.         localData.push(data);
  3099.         _GM_setValue(this.$key.STORAGE_KEY, localData);
  3100.         return true;
  3101.       } else {
  3102.         return false;
  3103.       }
  3104.     },
  3105.     /**
  3106.      * 更新数据
  3107.      * @param data
  3108.      */
  3109.     updateData(data) {
  3110.       let localData = this.getData();
  3111.       let index = localData.findIndex((item) => item.uuid == data.uuid);
  3112.       let updateFlag = false;
  3113.       if (index !== -1) {
  3114.         updateFlag = true;
  3115.         localData[index] = data;
  3116.       }
  3117.       this.setData(localData);
  3118.       return updateFlag;
  3119.     },
  3120.     /**
  3121.      * 删除数据
  3122.      * @param data
  3123.      */
  3124.     deleteData(data) {
  3125.       let localData = this.getData();
  3126.       let index = localData.findIndex((item) => item.uuid == data.uuid);
  3127.       let deleteFlag = false;
  3128.       if (index !== -1) {
  3129.         deleteFlag = true;
  3130.         localData.splice(index, 1);
  3131.       }
  3132.       this.setData(localData);
  3133.       return deleteFlag;
  3134.     },
  3135.     /**
  3136.      * 清空数据
  3137.      */
  3138.     clearData() {
  3139.       _GM_deleteValue(this.$key.STORAGE_KEY);
  3140.     },
  3141.     /**
  3142.      * 导出规则
  3143.      */
  3144.     exportRule(fileName = "rule.json") {
  3145.       let allRule = this.getData();
  3146.       let blob = new Blob([JSON.stringify(allRule, null, 4)]);
  3147.       let blobUrl = window.URL.createObjectURL(blob);
  3148.       let $a = domUtils.createElement("a");
  3149.       $a.href = blobUrl;
  3150.       $a.download = fileName;
  3151.       $a.click();
  3152.       setTimeout(() => {
  3153.         window.URL.revokeObjectURL(blobUrl);
  3154.       }, 1500);
  3155.     },
  3156.     /**
  3157.      * 导入规则
  3158.      */
  3159.     importRule() {
  3160.       let $alert = __pops.alert({
  3161.         title: {
  3162.           text: "请选择导入方式",
  3163.           position: "center"
  3164.         },
  3165.         content: {
  3166.           text: (
  3167.             /*html*/
  3168.             `
  3169.                     <div class="import-mode" data-mode="local">本地导入</div>
  3170.                     <div class="import-mode" data-mode="network">网络导入</div>
  3171.                 `
  3172.           ),
  3173.           html: true
  3174.         },
  3175.         width: PanelUISize.info.width,
  3176.         height: PanelUISize.info.height,
  3177.         style: (
  3178.           /*css*/
  3179.           `
  3180.                 .import-mode{
  3181.                     display: inline-block;
  3182.                     margin: 10px;
  3183.                     padding: 10px;
  3184.                     border: 1px solid #ccc;
  3185.                     border-radius: 5px;
  3186.                     cursor: pointer;
  3187.                 }
  3188.             `
  3189.         )
  3190.       });
  3191.       let $local = $alert.$shadowRoot.querySelector(
  3192.         ".import-mode[data-mode='local']"
  3193.       );
  3194.       let $network = $alert.$shadowRoot.querySelector(
  3195.         ".import-mode[data-mode='network']"
  3196.       );
  3197.       domUtils.on($local, "click", (event) => {
  3198.         utils.preventEvent(event);
  3199.         $alert.close();
  3200.         let $input = domUtils.createElement("input", {
  3201.           type: "file",
  3202.           accept: ".json"
  3203.         });
  3204.         domUtils.on($input, ["propertychange", "input"], (event2) => {
  3205.           if (!$input.files?.length) {
  3206.             return;
  3207.           }
  3208.           let uploadFile = $input.files[0];
  3209.           let fileReader = new FileReader();
  3210.           fileReader.onload = () => {
  3211.             let data = utils.toJSON(fileReader.result);
  3212.             if (!Array.isArray(data)) {
  3213.               log.error("不是正确的规则文件", data);
  3214.               Qmsg.error("不是正确的规则文件");
  3215.               return;
  3216.             }
  3217.             this.setData(data);
  3218.             Qmsg.success(`成功导入 ${data.length}条规则`);
  3219.           };
  3220.           fileReader.readAsText(uploadFile, "UTF-8");
  3221.         });
  3222.         $input.click();
  3223.       });
  3224.       domUtils.on($network, "click", (event) => {
  3225.         utils.preventEvent(event);
  3226.         $alert.close();
  3227.         __pops.prompt({
  3228.           title: {
  3229.             text: "网络导入",
  3230.             position: "center"
  3231.           },
  3232.           content: {
  3233.             text: "",
  3234.             placeholder: "url",
  3235.             focus: true
  3236.           },
  3237.           btn: {
  3238.             ok: {
  3239.               callback: async (eventDetails, event2) => {
  3240.                 let url = eventDetails.text;
  3241.                 if (utils.isNull(url)) {
  3242.                   Qmsg.error("请填入完整的url");
  3243.                   return;
  3244.                 }
  3245.                 let response = await httpx.get(url);
  3246.                 if (!response.status) {
  3247.                   return;
  3248.                 }
  3249.                 let data = utils.toJSON(response.data.responseText);
  3250.                 if (!Array.isArray(data)) {
  3251.                   log.error("不是正确的规则文件", response, data);
  3252.                   Qmsg.error("不是正确的规则文件");
  3253.                   return;
  3254.                 }
  3255.                 this.setData(data);
  3256.                 eventDetails.close();
  3257.                 Qmsg.success(`成功导入 ${data.length}条规则`);
  3258.               }
  3259.             }
  3260.           },
  3261.           width: PanelUISize.info.width,
  3262.           height: "auto"
  3263.         });
  3264.       });
  3265.     }
  3266.   };
  3267.   const CookieBackUpManager = {
  3268.     /**
  3269.      * 加密
  3270.      * @param text 要加密的文本
  3271.      * @param secretKey 密钥
  3272.      */
  3273.     encrypt(text, secretKey) {
  3274.       return CryptoJS.AES.encrypt(text, secretKey).toString();
  3275.     },
  3276.     /**
  3277.      * 解密
  3278.      * @param text 要解密的文本
  3279.      * @param secretKey 密钥
  3280.      */
  3281.     decrypt(text, secretKey) {
  3282.       const bytes = CryptoJS.AES.decrypt(text, secretKey);
  3283.       return bytes.toString(CryptoJS.enc.Utf8);
  3284.     },
  3285.     /**
  3286.      * 格式化导出的cookie
  3287.      */
  3288.     formatCookie(cookie, type, encodePwd) {
  3289.       let cookieText = "";
  3290.       if (type === "header_string") {
  3291.         cookieText = cookie.map((it) => {
  3292.           let cookieValue = it.value;
  3293.           return `${it.name}=${cookieValue}; `;
  3294.         }).join("");
  3295.       } else if (type === "json") {
  3296.         cookieText = JSON.stringify(
  3297.           {
  3298.             api: CookieManager.cookieManagerApiName,
  3299.             hostname: window.location.hostname,
  3300.             data: cookie
  3301.           },
  3302.           null,
  3303.           2
  3304.         );
  3305.       } else {
  3306.         throw new Error("不支持的格式化类型：" + type);
  3307.       }
  3308.       if (encodePwd) {
  3309.         cookieText = this.encrypt(cookieText, encodePwd);
  3310.       }
  3311.       return cookieText;
  3312.     },
  3313.     /**
  3314.      * 显示导出弹窗
  3315.      */
  3316.     showExportDialog() {
  3317.       let $confirm = __pops.confirm({
  3318.         title: {
  3319.           text: "导出 Cookie",
  3320.           position: "center"
  3321.         },
  3322.         content: {
  3323.           text: (
  3324.             /*html*/
  3325.             `
  3326. 						<p class="tip-text cookie-format-type-tip-text">您希望以哪种格式导出 Cookie？</p>
  3327. 						<div class="cookie-format-type-container">
  3328. 							<div class="cookie-format-type-item">
  3329. 								<input id="cookie-format-header_string" type="radio" name="format" value="header_string">
  3330. 								<label for="cookie-format-header_string">Header String</label>
  3331. 							</div>
  3332. 							<div class="cookie-format-type-item">
  3333. 								<input id="cookie-format-json" type="radio" name="format" value="json">
  3334. 								<label for="cookie-format-json">JSON</label>
  3335. 							</div>
  3336. 						</div>
  3337. 						<p class="tip-text export-example-code-tip-text">示例</p>
  3338. 						<div class="export-example-code-text-container">
  3339. 							<pre></pre>
  3340. 						</div>
  3341. 						<div class="cookir-format-encode-pwd-container">
  3342. 							<label for="hostOnly">用于加密 Cookie 的密码</label>
  3343. 							<input id="encode-pwd" type="password" placeholder="用于加密 Cookie 的密码" value="">
  3344. 							<p>如果您希望在导出前加密 Cookie，请输入密码（可选）。</p>
  3345. 						</div>
  3346. 					`
  3347.           ),
  3348.           html: true
  3349.         },
  3350.         width: window.innerWidth < 400 ? "88vw" : "400px",
  3351.         height: "auto",
  3352.         btn: {
  3353.           merge: true,
  3354.           position: "space-between",
  3355.           ok: {
  3356.             text: "导出",
  3357.             async callback(eventDetails, event) {
  3358.               let cookieList = CookieManagerView.$data.cookieList;
  3359.               if (cookieList.length === 0) {
  3360.                 Qmsg.warning("Cookie为空");
  3361.                 return;
  3362.               }
  3363.               let cookieText = CookieBackUpManager.formatCookie(
  3364.                 cookieList,
  3365.                 dialogConfig.exportType,
  3366.                 dialogConfig.encodePwd
  3367.               );
  3368.               const blob = new Blob([cookieText], { type: "text/plain" });
  3369.               const url = URL.createObjectURL(blob);
  3370.               let $anchor = domUtils.createElement("a", {
  3371.                 download: `${window.location.hostname}_${dialogConfig.exportType}_${CookieManager.cookieManagerApiName}_${Date.now()}.txt`,
  3372.                 href: url,
  3373.                 target: "_blank"
  3374.               });
  3375.               $anchor.click();
  3376.               setTimeout(() => {
  3377.                 URL.revokeObjectURL(url);
  3378.               }, 500);
  3379.               eventDetails.close();
  3380.             }
  3381.           },
  3382.           other: {
  3383.             enable: true,
  3384.             text: "导出至剪贴板",
  3385.             type: "xiaomi-primary",
  3386.             async callback(eventDetails, event) {
  3387.               let cookieList = CookieManagerView.$data.cookieList;
  3388.               if (cookieList.length === 0) {
  3389.                 Qmsg.warning("Cookie为空");
  3390.                 return;
  3391.               }
  3392.               let cookieText = CookieBackUpManager.formatCookie(
  3393.                 cookieList,
  3394.                 dialogConfig.exportType,
  3395.                 dialogConfig.encodePwd
  3396.               );
  3397.               const status = await utils.setClip(cookieText);
  3398.               if (status) {
  3399.                 Qmsg.success("复制成功");
  3400.               } else {
  3401.                 Qmsg.error("复制失败");
  3402.               }
  3403.               eventDetails.close();
  3404.             }
  3405.           }
  3406.         },
  3407.         style: (
  3408.           /*css*/
  3409.           `
  3410. 					${__pops.config.cssText.panelCSS}
  3411.  
  3412. 					.pops-content{
  3413. 						padding: 20px;
  3414. 					}
  3415. 					.cookie-format-type-container{
  3416. 						display: flex;
  3417. 						gap: 10px;
  3418. 						margin: 10px 0px;
  3419. 						align-items: center;
  3420. 						flex-wrap: wrap;
  3421. 						justify-content: space-between;
  3422. 					}
  3423. 					.cookie-format-type-item input[type="radio"]{
  3424. 						width: 1rem;
  3425. 						height: 1rem;
  3426. 					}
  3427. 					.export-example-code-text-container{
  3428. 						padding: 10px;
  3429. 						background-color: rgb(209 213 219 / 1);
  3430. 						border-radius: 10px;
  3431. 						width: 100%;
  3432. 						margin: 1rem 0px;
  3433. 					}
  3434. 					.export-example-code-text-container pre{
  3435. 						font-feature-settings: normal;
  3436. 						font-variation-settings: normal;
  3437. 						font-size: 1em;
  3438. 						margin: 0;
  3439. 						white-space: break-spaces;
  3440. 					}
  3441. 					.cookie-format-type-container label{
  3442. 						color: rgb(17 24 39 / 1);
  3443. 					}
  3444. 					.cookir-format-encode-pwd-container label{
  3445. 						color: #111827;
  3446. 					}
  3447. 					.cookie-format-type-tip-text,
  3448. 					.export-example-code-tip-text,
  3449. 					.cookir-format-encode-pwd-container label{
  3450. 						font-weight: 600;
  3451. 					}
  3452. 					.cookir-format-encode-pwd-container input{
  3453. 						border-radius: 0.5rem;
  3454. 						width: 100%;
  3455. 						border: 1px solid #d1d5db;
  3456. 						background-color: #f9fafb;
  3457. 						padding: 0.625rem;
  3458. 						margin: 0.65rem 0px;
  3459. 						font-size: 12px;
  3460. 						color: #111827;
  3461. 					}
  3462. 					.cookir-format-encode-pwd-container p{
  3463.     					color: #6b7280;
  3464. 						font-size: 12px;
  3465. 					}
  3466. 				`
  3467.         )
  3468.       });
  3469.       let $exampleCodeText = $confirm.$shadowRoot.querySelector(
  3470.         ".export-example-code-text-container pre"
  3471.       );
  3472.       let $format_header_string = $confirm.$shadowRoot.querySelector(
  3473.         "#cookie-format-header_string"
  3474.       );
  3475.       let $format_json = $confirm.$shadowRoot.querySelector("#cookie-format-json");
  3476.       let $encodePwd = $confirm.$shadowRoot.querySelector("#encode-pwd");
  3477.       const DialogConfigManager = {
  3478.         key: "cookie-backup-export-dialog-config",
  3479.         getConfig() {
  3480.           return Panel.getValue(this.key, {
  3481.             exportType: "header_string",
  3482.             encodePwd: ""
  3483.           });
  3484.         },
  3485.         saveConfig() {
  3486.           let exportType = "header_string";
  3487.           if ($format_json.checked) {
  3488.             exportType = "json";
  3489.           }
  3490.           Panel.setValue(this.key, {
  3491.             exportType,
  3492.             encodePwd: domUtils.val($encodePwd)
  3493.           });
  3494.           dialogConfig = this.getConfig();
  3495.         }
  3496.       };
  3497.       let dialogConfig = DialogConfigManager.getConfig();
  3498.       domUtils.on($format_header_string, "input", () => {
  3499.         const exampleCooikieList = [
  3500.           {
  3501.             name: "_ga",
  3502.             value: "GA1.2.123456789.987654321",
  3503.             domain: window.location.hostname,
  3504.             expires: Date.now() + 1e3 * 60 * 60 * 24 * 30,
  3505.             partitioned: false,
  3506.             path: "/",
  3507.             sameSite: "unspecified",
  3508.             secure: false
  3509.           },
  3510.           {
  3511.             name: "PHPSESSID",
  3512.             value: "28f2d88ee9322cfd2e4f1e",
  3513.             domain: window.location.hostname,
  3514.             expires: Date.now() + 1e3 * 60 * 60 * 24 * 30,
  3515.             partitioned: false,
  3516.             path: "/",
  3517.             sameSite: "unspecified",
  3518.             secure: false
  3519.           },
  3520.           {
  3521.             name: "csrftoken",
  3522.             value: "abcdef123456",
  3523.             domain: window.location.hostname,
  3524.             expires: Date.now() + 1e3 * 60 * 60 * 24 * 30,
  3525.             partitioned: false,
  3526.             path: "/",
  3527.             sameSite: "unspecified",
  3528.             secure: false
  3529.           },
  3530.           {
  3531.             name: "logged_in",
  3532.             value: "true",
  3533.             domain: window.location.hostname,
  3534.             expires: Date.now() + 1e3 * 60 * 60 * 24 * 30,
  3535.             partitioned: false,
  3536.             path: "/",
  3537.             sameSite: "unspecified",
  3538.             secure: false
  3539.           }
  3540.         ];
  3541.         let exampleText = this.formatCookie(exampleCooikieList, "header_string");
  3542.         domUtils.text($exampleCodeText, exampleText);
  3543.         DialogConfigManager.saveConfig();
  3544.       });
  3545.       domUtils.on($format_json, "input", () => {
  3546.         const exampleCooikieList = [
  3547.           {
  3548.             name: "sessionId",
  3549.             value: "abc123xyz456",
  3550.             domain: ".example.com",
  3551.             path: "/",
  3552.             secure: true,
  3553.             httpOnly: true,
  3554.             sameSite: "lax",
  3555.             expirationDate: 1713543600,
  3556.             hostOnly: false,
  3557.             session: false
  3558.           }
  3559.         ];
  3560.         let exampleText = this.formatCookie(exampleCooikieList, "json");
  3561.         domUtils.text($exampleCodeText, exampleText);
  3562.         DialogConfigManager.saveConfig();
  3563.       });
  3564.       domUtils.on($encodePwd, ["input", "propertychange"], () => {
  3565.         DialogConfigManager.saveConfig();
  3566.       });
  3567.       if (dialogConfig.exportType === "header_string") {
  3568.         $format_header_string.click();
  3569.       } else if (dialogConfig.exportType === "json") {
  3570.         $format_json.click();
  3571.       }
  3572.       domUtils.val($encodePwd, dialogConfig.encodePwd);
  3573.     },
  3574.     /**
  3575.      * 显示导入弹窗
  3576.      */
  3577.     showImportDialog() {
  3578.       let $confirm = __pops.confirm({
  3579.         title: {
  3580.           text: "导入 Cookie",
  3581.           position: "center"
  3582.         },
  3583.         content: {
  3584.           text: (
  3585.             /*html*/
  3586.             `
  3587. 						<p class="tip-text cookie-format-type-tip-text">您希望如何导入？</p>
  3588. 						<div class="import-cookie-type-container">
  3589. 							<div class="import-cookie-type-item">
  3590. 								<input id="import-cookie-import_from_text" type="radio" name="format" value="import_from_text">
  3591. 								<label for="import-cookie-import_from_text">Use text</label>
  3592. 							</div>
  3593. 							<div class="import-cookie-type-item">
  3594. 								<input id="import-cookie-import_from_file" type="radio" name="format" value="import_from_file">
  3595. 								<label for="import-cookie-import_from_file">Use a file</label>
  3596. 							</div>
  3597. 						</div>
  3598. 						<div class="import-cookie-value-container">
  3599. 							<div class="import-cookie-value-text">
  3600. 								<label>Cookie value</label>
  3601. 								<textarea rows="5" placeholder="Header string/JSON"></textarea>
  3602. 							</div>
  3603. 							<div class="import-cookie-value-file">
  3604. 								<label>选择要导入的文件</label>
  3605. 								<input accept=".txt, .json" type="file">
  3606. 							</div>
  3607. 						</div>
  3608. 						<div class="cookie-format-decode-pwd-container">
  3609. 							<label for="hostOnly">用于解密 Cookie 的密码</label>
  3610. 							<input id="decode-pwd" type="password" placeholder="用于解密 Cookie 的密码" value="">
  3611. 							<p>如果 Cookie 受加密保护，请输入解密密码（可选）。</p>
  3612. 						</div>
  3613. 					`
  3614.           ),
  3615.           html: true
  3616.         },
  3617.         width: window.innerWidth < 400 ? "88vw" : "400px",
  3618.         height: "auto",
  3619.         btn: {
  3620.           ok: {
  3621.             text: "导入",
  3622.             async callback(eventDetails, event) {
  3623.               try {
  3624.                 const decodePwd = dialogConfig.decodePwd;
  3625.                 let cookieListStr = dialogConfig.value;
  3626.                 if (decodePwd.trim() === "") {
  3627.                 } else {
  3628.                   cookieListStr = CookieBackUpManager.decrypt(cookieListStr, decodePwd);
  3629.                 }
  3630.                 const cookie = utils.toJSON(cookieListStr);
  3631.                 if (Array.isArray(cookie)) {
  3632.                   log.info(`使用${CookieManager.cookieManagerApiName}导入cookie数据`);
  3633.                   for (const cookieInfo of cookie) {
  3634.                     await CookieManager.updateCookie(cookieInfo);
  3635.                   }
  3636.                 } else if (typeof cookie === "object" && Object.keys(cookie).length && Array.isArray(cookie["data"])) {
  3637.                   const cookieManager2 = new CookieManagerService(cookie.api);
  3638.                   log.info(`使用${cookieManager2.cookieManagerApiName}导入cookie数据`);
  3639.                   for (const cookieInfo of cookie.data) {
  3640.                     await cookieManager2.updateCookie(cookieInfo);
  3641.                   }
  3642.                 } else if (typeof cookie === "object" && !Object.keys(cookie).length) {
  3643.                   let utilsCookieManager = new utils.GM_Cookie();
  3644.                   log.info(`使用${CookieManager.cookieManagerApiName}导入cookie数据`);
  3645.                   let cookieObj = utilsCookieManager.parseCookie(cookieListStr);
  3646.                   for (const cookieInfo of cookieObj) {
  3647.                     await CookieManager.updateCookie({
  3648.                       name: cookieInfo.key,
  3649.                       value: cookieInfo.value,
  3650.                       domain: window.location.hostname,
  3651.                       path: "/",
  3652.                       sameSite: "unspecified",
  3653.                       secure: false,
  3654.                       session: false,
  3655.                       hostOnly: true,
  3656.                       httpOnly: false
  3657.                     });
  3658.                   }
  3659.                 } else {
  3660.                   log.error(cookieListStr, cookie);
  3661.                   Qmsg.error("cookie格式不符合");
  3662.                   return;
  3663.                 }
  3664.                 eventDetails.close();
  3665.               } catch (error) {
  3666.                 Qmsg.error(error.toString());
  3667.               }
  3668.             }
  3669.           }
  3670.         },
  3671.         style: (
  3672.           /*css*/
  3673.           `
  3674. 					${__pops.config.cssText.panelCSS}
  3675.  
  3676. 					.pops-content{
  3677. 						padding: 20px;
  3678. 					}
  3679. 					.import-cookie-type-container{
  3680. 						display: flex;
  3681. 						gap: 10px;
  3682. 						margin: 10px 0px;
  3683. 						align-items: center;
  3684. 						flex-wrap: wrap;
  3685. 						justify-content: space-between;
  3686. 					}
  3687. 					.import-cookie-type-item input[type="radio"]{
  3688. 						width: 1rem;
  3689. 						height: 1rem;
  3690. 					}
  3691. 					.export-example-code-text-container{
  3692. 						padding: 10px;
  3693. 						background-color: rgb(209 213 219 / 1);
  3694. 						border-radius: 10px;
  3695. 						width: 100%;
  3696. 						margin: 1rem 0px;
  3697. 					}
  3698. 					.export-example-code-text-container pre{
  3699. 						font-feature-settings: normal;
  3700. 						font-variation-settings: normal;
  3701. 						font-size: 1em;
  3702. 						margin: 0;
  3703. 						white-space: break-spaces;
  3704. 					}
  3705. 					.import-cookie-type-container label{
  3706. 						color: rgb(17 24 39 / 1);
  3707. 					}
  3708. 					.cookie-format-decode-pwd-container label{
  3709. 						color: #111827;
  3710. 					}
  3711. 					.import-cookie-value-text label,
  3712. 					.import-cookie-value-file label,
  3713. 					.cookie-format-type-tip-text,
  3714. 					.cookie-format-decode-pwd-container label{
  3715. 						font-weight: 600;
  3716. 					}
  3717. 					.cookie-format-decode-pwd-container input{
  3718. 						border-radius: 0.5rem;
  3719. 						width: 100%;
  3720. 						border: 1px solid #d1d5db;
  3721. 						background-color: #f9fafb;
  3722. 						padding: 0.625rem;
  3723. 						margin: 0.65rem 0px;
  3724. 						font-size: 12px;
  3725. 						color: #111827;
  3726. 					}
  3727. 					.cookie-format-decode-pwd-container p{
  3728.     					color: #6b7280;
  3729. 						font-size: 12px;
  3730. 					}
  3731.  
  3732. 					.import-cookie-value-text{
  3733. 						display: flex;
  3734. 						flex-direction: column;
  3735. 					}
  3736. 					.import-cookie-value-text label{
  3737.  
  3738. 					}
  3739. 					.import-cookie-value-text textarea{
  3740. 						font-size: 0.875rem;
  3741. 						line-height: 1.25rem;
  3742. 						padding: 0.625rem;
  3743. 						color: rgb(17 24 39 / 1);
  3744. 						background-color: rgb(249 250 251 / 1);
  3745. 						border: 1px solid rgb(209 213 219 / 1);
  3746. 						border-radius: 0.5rem;
  3747. 						width: 100%;
  3748. 						margin: 10px 0px;
  3749. 					}
  3750. 					.import-cookie-value-file{
  3751. 						display: flex;
  3752. 						flex-direction: column;
  3753. 					}
  3754. 					.import-cookie-value-file label{
  3755.  
  3756. 					}
  3757. 					.import-cookie-value-file input{
  3758. 						border: 1px solid #d1d5db;
  3759. 						border-radius: 0.5rem;
  3760. 						height: 2.25rem;
  3761. 						width: 100%;
  3762. 						margin: 1rem 0px;
  3763. 					}
  3764. 					.import-cookie-value-file input:hover,					
  3765. 					.import-cookie-value-file input::file-selector-button:hover{
  3766. 						cursor: pointer;
  3767. 					}
  3768. 					.import-cookie-value-file input::file-selector-button{
  3769. 						background-color: #1E2939;
  3770. 						color: #ffffff;
  3771. 						height: 100%;
  3772. 						box-sizing: border-box;
  3773. 					}
  3774. 					.import-cookie-value-file input::file-selector-button:hover{
  3775. 						background-color: #364153;
  3776. 					}
  3777. 				`
  3778.         )
  3779.       });
  3780.       let import_file_text = "";
  3781.       let $import_cookie_from_text = $confirm.$shadowRoot.querySelector(
  3782.         "#import-cookie-import_from_text"
  3783.       );
  3784.       let $import_cookie_from_file = $confirm.$shadowRoot.querySelector(
  3785.         "#import-cookie-import_from_file"
  3786.       );
  3787.       $confirm.$shadowRoot.querySelector(
  3788.         ".import-cookie-value-container"
  3789.       );
  3790.       let $importContainer_text = $confirm.$shadowRoot.querySelector(
  3791.         ".import-cookie-value-text"
  3792.       );
  3793.       let $import_text = $importContainer_text.querySelector("textarea");
  3794.       let $importContainer_file = $confirm.$shadowRoot.querySelector(
  3795.         ".import-cookie-value-file"
  3796.       );
  3797.       let $import_file = $importContainer_file.querySelector("input");
  3798.       let $decodePwd = $confirm.$shadowRoot.querySelector("#decode-pwd");
  3799.       const DialogConfigManager = {
  3800.         key: "cookie-backup-import-dialog-config",
  3801.         getConfig() {
  3802.           let config = Panel.getValue(this.key, {
  3803.             importType: "import_from_text",
  3804.             decodePwd: "",
  3805.             value: ""
  3806.           });
  3807.           if (config.importType === "import_from_text") {
  3808.             config.value = $import_text.value;
  3809.           } else if (config.importType === "import_from_file") {
  3810.             config.value = import_file_text;
  3811.           }
  3812.           return config;
  3813.         },
  3814.         saveConfig() {
  3815.           let importType = "import_from_text";
  3816.           if ($import_cookie_from_file.checked) {
  3817.             importType = "import_from_file";
  3818.           }
  3819.           Panel.setValue(this.key, {
  3820.             importType,
  3821.             decodePwd: domUtils.val($decodePwd)
  3822.           });
  3823.           dialogConfig = this.getConfig();
  3824.         }
  3825.       };
  3826.       let dialogConfig = DialogConfigManager.getConfig();
  3827.       domUtils.on($import_cookie_from_text, "input", () => {
  3828.         DialogConfigManager.saveConfig();
  3829.         $import_file.value = "";
  3830.         import_file_text = "";
  3831.         domUtils.hide($importContainer_file, false);
  3832.         domUtils.show($importContainer_text, false);
  3833.       });
  3834.       domUtils.on($import_cookie_from_file, "input", () => {
  3835.         DialogConfigManager.saveConfig();
  3836.         $import_text.value = "";
  3837.         domUtils.hide($importContainer_text, false);
  3838.         domUtils.show($importContainer_file, false);
  3839.       });
  3840.       domUtils.on(
  3841.         $import_text,
  3842.         ["input", "propertychange"],
  3843.         utils.debounce(() => {
  3844.           DialogConfigManager.saveConfig();
  3845.         })
  3846.       );
  3847.       domUtils.on($import_file, ["change", "input"], (evt) => {
  3848.         const file = $import_file.files?.[0];
  3849.         if (file) {
  3850.           const reader = new FileReader();
  3851.           reader.onload = function(e) {
  3852.             const content = e.target.result;
  3853.             if (typeof content === "string") {
  3854.               import_file_text = content;
  3855.               DialogConfigManager.saveConfig();
  3856.             }
  3857.           };
  3858.           reader.readAsText(file);
  3859.         }
  3860.       });
  3861.       domUtils.on($decodePwd, ["input", "propertychange"], async (evt) => {
  3862.         DialogConfigManager.saveConfig();
  3863.       });
  3864.       if (dialogConfig.importType === "import_from_text") {
  3865.         $import_cookie_from_text.click();
  3866.       } else if (dialogConfig.importType === "import_from_file") {
  3867.         $import_cookie_from_file.click();
  3868.       }
  3869.       domUtils.val($decodePwd, dialogConfig.decodePwd);
  3870.     }
  3871.   };
  3872.   const CookieManagerView = {
  3873.     $data: {
  3874.       /**
  3875.        * 当前的cookie列表
  3876.        */
  3877.       cookieList: []
  3878.     },
  3879.     init() {
  3880.       this.registerMenu();
  3881.     },
  3882.     /**
  3883.      * 显示视图
  3884.      */
  3885.     async showView() {
  3886.       const $alert = __pops.alert({
  3887.         title: {
  3888.           text: "Cookie编辑器",
  3889.           html: false,
  3890.           position: "center"
  3891.         },
  3892.         content: {
  3893.           text: (
  3894.             /*html*/
  3895.             `
  3896.                     <div class="cookie-wrapper">
  3897.                         <div class="cookie-search-wrapper">
  3898.                             <div class="cookie-search-inner">
  3899.                                 <input type="text" placeholder="搜索Cookie名称">
  3900.                             </div>
  3901.                             <div class="cookie-search-setting">
  3902.                                 <svg class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4368" width="28" height="28">
  3903.                                     <path fill="#2c2c2c" d="M439.264 208a16 16 0 0 0-16 16v67.968a239.744 239.744 0 0 0-46.496 26.896l-58.912-34a16 16 0 0 0-21.856 5.856l-80 138.56a16 16 0 0 0 5.856 21.856l58.896 34a242.624 242.624 0 0 0 0 53.728l-58.88 34a16 16 0 0 0-6.72 20.176l0.848 1.68 80 138.56a16 16 0 0 0 21.856 5.856l58.912-34a239.744 239.744 0 0 0 46.496 26.88V800a16 16 0 0 0 16 16h160a16 16 0 0 0 16-16v-67.968a239.744 239.744 0 0 0 46.512-26.896l58.912 34a16 16 0 0 0 21.856-5.856l80-138.56a16 16 0 0 0-4.288-20.832l-1.568-1.024-58.896-34a242.624 242.624 0 0 0 0-53.728l58.88-34a16 16 0 0 0 6.72-20.176l-0.848-1.68-80-138.56a16 16 0 0 0-21.856-5.856l-58.912 34a239.744 239.744 0 0 0-46.496-26.88V224a16 16 0 0 0-16-16h-160z m32 48h96v67.376l28.8 12.576c13.152 5.76 25.632 12.976 37.184 21.52l25.28 18.688 58.448-33.728 48 83.136-58.368 33.68 3.472 31.2a194.624 194.624 0 0 1 0 43.104l-3.472 31.2 58.368 33.68-48 83.136-58.432-33.728-25.296 18.688c-11.552 8.544-24.032 15.76-37.184 21.52l-28.8 12.576V768h-96v-67.376l-28.784-12.576c-13.152-5.76-25.632-12.976-37.184-21.52l-25.28-18.688-58.448 33.728-48-83.136 58.368-33.68-3.472-31.2a194.624 194.624 0 0 1 0-43.104l3.472-31.2-58.368-33.68 48-83.136 58.432 33.728 25.296-18.688a191.744 191.744 0 0 1 37.184-21.52l28.8-12.576V256z m47.28 144a112 112 0 1 0 0 224 112 112 0 0 0 0-224z m0 48a64 64 0 1 1 0 128 64 64 0 0 1 0-128z"></path>
  3904.                                 </svg>
  3905.                             </div>
  3906.                         </div>
  3907.                         <div class="cookie-control-wrapper">
  3908.                             <button class="cookie-control-refresh" type="button" data-type="default">刷新</button>
  3909.                             <button class="cookie-control-add" type="button" data-type="default">添加</button>
  3910.                             <button class="cookie-control-export" type="button" data-type="default">导出</button>
  3911.                             <button class="cookie-control-import" type="button" data-type="default">导入</button>
  3912.                             <button class="cookie-control-clear-all" type="button" data-type="default">删除</button>
  3913.                             <button class="cookie-control-rule-manager" type="button" data-type="default">规则管理</button>
  3914.                             <div class="cookie-setting"> 
  3915.                                 <svg class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4368" width="28" height="28">
  3916.                                     <path fill="#2c2c2c" d="M439.264 208a16 16 0 0 0-16 16v67.968a239.744 239.744 0 0 0-46.496 26.896l-58.912-34a16 16 0 0 0-21.856 5.856l-80 138.56a16 16 0 0 0 5.856 21.856l58.896 34a242.624 242.624 0 0 0 0 53.728l-58.88 34a16 16 0 0 0-6.72 20.176l0.848 1.68 80 138.56a16 16 0 0 0 21.856 5.856l58.912-34a239.744 239.744 0 0 0 46.496 26.88V800a16 16 0 0 0 16 16h160a16 16 0 0 0 16-16v-67.968a239.744 239.744 0 0 0 46.512-26.896l58.912 34a16 16 0 0 0 21.856-5.856l80-138.56a16 16 0 0 0-4.288-20.832l-1.568-1.024-58.896-34a242.624 242.624 0 0 0 0-53.728l58.88-34a16 16 0 0 0 6.72-20.176l-0.848-1.68-80-138.56a16 16 0 0 0-21.856-5.856l-58.912 34a239.744 239.744 0 0 0-46.496-26.88V224a16 16 0 0 0-16-16h-160z m32 48h96v67.376l28.8 12.576c13.152 5.76 25.632 12.976 37.184 21.52l25.28 18.688 58.448-33.728 48 83.136-58.368 33.68 3.472 31.2a194.624 194.624 0 0 1 0 43.104l-3.472 31.2 58.368 33.68-48 83.136-58.432-33.728-25.296 18.688c-11.552 8.544-24.032 15.76-37.184 21.52l-28.8 12.576V768h-96v-67.376l-28.784-12.576c-13.152-5.76-25.632-12.976-37.184-21.52l-25.28-18.688-58.448 33.728-48-83.136 58.368-33.68-3.472-31.2a194.624 194.624 0 0 1 0-43.104l3.472-31.2-58.368-33.68 48-83.136 58.432 33.728 25.296-18.688a191.744 191.744 0 0 1 37.184-21.52l28.8-12.576V256z m47.28 144a112 112 0 1 0 0 224 112 112 0 0 0 0-224z m0 48a64 64 0 1 1 0 128 64 64 0 0 1 0-128z"></path>
  3917.                                 </svg>
  3918.                             </div>
  3919.                         </div>
  3920.                         <div class="cookie-list-wrapper">
  3921.                         </div>
  3922.                     </div>
  3923.                 `
  3924.           ),
  3925.           html: true
  3926.         },
  3927.         btn: {
  3928.           ok: {
  3929.             enable: false
  3930.           }
  3931.         },
  3932.         mask: {
  3933.           enable: true
  3934.         },
  3935.         drag: true,
  3936.         width: PanelUISize.setting.width,
  3937.         height: PanelUISize.setting.height,
  3938.         style: (
  3939.           /*css*/
  3940.           `
  3941.                 ${__pops.config.cssText.panelCSS}
  3942.                 .cookie-wrapper{
  3943.                     display: flex;
  3944.                     flex-direction: column;
  3945.                     padding: 10px;
  3946.                     gap: 10px;
  3947.                 }
  3948.                 .cookie-control-wrapper{
  3949.                     display: flex;
  3950. 					flex-wrap: wrap;
  3951.                     padding: 0px 10px;
  3952.                     gap: 5px;
  3953.                     --button-margin-left: 0px;
  3954.                 }
  3955.                 .cookie-search-wrapper{
  3956.                     display: flex;
  3957.                     align-items: center;
  3958.                 }
  3959.                 .cookie-search-inner{
  3960.                     width: 100%;
  3961.                     padding: 0px 10px;
  3962.                 }
  3963.                 .cookie-search-inner input{
  3964.                     height: 30px;
  3965.                     padding: 5px 8px;
  3966.                     width: 100%;
  3967. 					border-radius: 6px;
  3968.                 }
  3969. 				.cookie-search-inner input::placeholder{
  3970. 					display: flex;
  3971. 					align-items: baseline;
  3972. 				}
  3973.                 .cookie-search-inner input:focus-visible{
  3974.                     outline: none;
  3975.                 }
  3976.                 .cookie-setting,
  3977.                 .cookie-search-setting{
  3978.                     display: flex;
  3979.                     align-items: center;
  3980.                 }
  3981.                 .cookie-setting svg,
  3982.                 .cookie-search-setting svg{
  3983.                     cursor: pointer;
  3984.                 }
  3985.                 .cookie-list-wrapper{
  3986.                     display: flex;
  3987.                     flex-wrap: wrap;
  3988.                     gap: 10px;
  3989.                 }
  3990.                 .cookie-item{
  3991.                     display: flex;
  3992.                     flex-direction: column;
  3993.                     padding: 10px 10px;
  3994.                     margin: 0px 10px;
  3995.                     background: #f1efef;
  3996.                     border-radius: 10px;
  3997.                     gap: 5px;
  3998.                     box-sizing: border-box;
  3999.                     width: 100%;
  4000.                 }
  4001.                 .cookie-item-group{
  4002.                     display: flex;
  4003.                     align-items: center;
  4004.                 }
  4005.                 .cookie-item-group-left{
  4006.                     width: 100px;
  4007.                     min-width: 100px;
  4008.                     max-width: 100px;
  4009.                     text-transform: capitalize
  4010.                 }
  4011.                 .cookie-item-group-control .cookie-item-group-right{
  4012.                     display: flex;
  4013.                     align-items: center;
  4014.                     gap: 10px;
  4015.                 }
  4016.                 .cookie-item-group-control .cookie-item-group-control-copy,
  4017.                 .cookie-item-group-control .cookie-item-group-control-edit,
  4018.                 .cookie-item-group-control .cookie-item-group-control-delete{
  4019.                     display: flex;
  4020.                     align-items: center;
  4021.                 }
  4022.                 .cookie-item-group-control .cookie-item-group-control-delete svg{
  4023.                     width: 16px;
  4024.                     height: 16px;
  4025.                 }
  4026.                 .cookie-item-group-control svg{
  4027.                     cursor: pointer;
  4028.                 }
  4029.             `
  4030.         )
  4031.       });
  4032.       const $search = $alert.$shadowRoot.querySelector(".cookie-search-inner input");
  4033.       const $searchSetting = $alert.$shadowRoot.querySelector(".cookie-search-setting");
  4034.       const $refresh = $alert.$shadowRoot.querySelector(".cookie-control-refresh");
  4035.       const $add = $alert.$shadowRoot.querySelector(".cookie-control-add");
  4036.       const $export = $alert.$shadowRoot.querySelector(".cookie-control-export");
  4037.       const $import = $alert.$shadowRoot.querySelector(".cookie-control-import");
  4038.       const $clearAll = $alert.$shadowRoot.querySelector(".cookie-control-clear-all");
  4039.       const $ruleManager = $alert.$shadowRoot.querySelector(".cookie-control-rule-manager");
  4040.       const $setting = $alert.$shadowRoot.querySelector(".cookie-setting");
  4041.       const $cookieListWrapper = $alert.$shadowRoot.querySelector(".cookie-list-wrapper");
  4042.       let createCookieItemElement = (cookieInfo) => {
  4043.         const $cookieItem = domUtils.createElement("div", {
  4044.           className: "cookie-item",
  4045.           innerHTML: (
  4046.             /*html*/
  4047.             `
  4048.                 `
  4049.           ),
  4050.           "data-cookie-info": cookieInfo
  4051.         });
  4052.         const cookieProperty = [
  4053.           {
  4054.             leftText: "name",
  4055.             rightText: cookieInfo.name
  4056.           },
  4057.           {
  4058.             leftText: "value",
  4059.             // 解码值
  4060.             rightText: Panel.getValue("decode-cookie-value") ? decodeURIComponent(cookieInfo.value) : encodeURIComponent(cookieInfo.value)
  4061.           }
  4062.         ];
  4063.         if (CookieManager.cookieManagerApiName === "GM_cookie" || CookieManager.cookieManagerApiName === "GM.cookie") {
  4064.           cookieInfo = cookieInfo;
  4065.           cookieProperty.push(
  4066.             {
  4067.               leftText: "domain",
  4068.               rightText: cookieInfo.domain
  4069.             },
  4070.             {
  4071.               leftText: "path",
  4072.               rightText: cookieInfo.path
  4073.             },
  4074.             {
  4075.               leftText: "session",
  4076.               rightText: JSON.stringify(cookieInfo.session)
  4077.             },
  4078.             {
  4079.               leftText: "expires",
  4080.               rightText: cookieInfo.session ? "会话" : cookieInfo.expirationDate ? new Date(cookieInfo.expirationDate * 1e3).toISOString() : "未知"
  4081.             },
  4082.             {
  4083.               leftText: "httpOnly",
  4084.               rightText: JSON.stringify(cookieInfo.httpOnly)
  4085.             },
  4086.             {
  4087.               leftText: "hostOnly",
  4088.               rightText: JSON.stringify(cookieInfo.hostOnly)
  4089.             },
  4090.             {
  4091.               leftText: "secure",
  4092.               rightText: JSON.stringify(cookieInfo.secure)
  4093.             },
  4094.             {
  4095.               leftText: "sameSite",
  4096.               rightText: cookieInfo.sameSite
  4097.             }
  4098.           );
  4099.         } else if (CookieManager.cookieManagerApiName === "cookieStore") {
  4100.           cookieInfo = cookieInfo;
  4101.           cookieProperty.push(
  4102.             {
  4103.               leftText: "domain",
  4104.               rightText: cookieInfo.domain
  4105.             },
  4106.             {
  4107.               leftText: "path",
  4108.               rightText: cookieInfo.path
  4109.             },
  4110.             {
  4111.               leftText: "expires",
  4112.               rightText: cookieInfo.expires ? new Date(cookieInfo.expires).toISOString() : "会话"
  4113.             },
  4114.             {
  4115.               leftText: "secure",
  4116.               rightText: JSON.stringify(cookieInfo.secure)
  4117.             },
  4118.             {
  4119.               leftText: "sameSite",
  4120.               rightText: cookieInfo.sameSite
  4121.             }
  4122.           );
  4123.         }
  4124.         cookieProperty.forEach((it) => {
  4125.           const $cookieItemGroup = domUtils.createElement("div", {
  4126.             className: "cookie-item-group",
  4127.             innerHTML: (
  4128.               /*html*/
  4129.               `
  4130.                         <div class="cookie-item-group-left">
  4131.                             <p>${it.leftText}</p>
  4132.                         </div>
  4133.                         <div class="cookie-item-group-right">
  4134.                             <p>${it.rightText}</p>
  4135.                         </div>
  4136.                     `
  4137.             )
  4138.           });
  4139.           domUtils.append($cookieItem, $cookieItemGroup);
  4140.         });
  4141.         let $cookieItemGroupControl = domUtils.createElement("div", {
  4142.           className: "cookie-item-group cookie-item-group-control",
  4143.           innerHTML: (
  4144.             /*html*/
  4145.             `
  4146.                     <div class="cookie-item-group-left">操作</div>
  4147.                     <div class="cookie-item-group-right">
  4148.                         <div class="cookie-item-group-control-copy">
  4149.                             <svg t="1742795616339" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" width="16" height="16">
  4150.                                 <path d="M880 247.008l-162.016-166.016Q700.992 64 677.984 64h-316.992q-26.016 0-46.016 18.016-16.992 15.008-23.008 36.992H231.968q-43.008 0-73.504 31.008t-30.496 76v627.008q0 44 30.496 75.488T231.968 960h508q43.008 0 73.504-31.488t30.496-75.488v-63.008q23.008-6.016 37.504-25.504t14.496-44.512V287.008q0-24-16-40z m-168-160.992l-3.008-3.008z m98.016 177.984L744 196z m-126.016-116.992l108 110.016h-108V147.008zM676.992 128zM204.992 948q4 0.992 4.992 2.016-2.016-0.992-4.992-2.016z m27.008 4q-6.016 0-12-0.992 4.992 0.992 12 0.992z m543.008-99.008q0 15.008-10.016 25.504t-24.992 10.496H232q-14.016 0-24.512-10.496t-10.496-25.504V225.984q0-15.008 10.496-25.504t24.512-10.496h58.016v531.008q0 30.016 20.992 51.008t50.016 20.992H775.04v60z m52-132.992q0 2.016-2.016 2.016h-464q-2.016 0-2.016-2.016V136.992q0-2.016 2.016-2.016h251.008v156.992q0 15.008 10.016 24.992t24 10.016h180.992v392.992z m9.984 64q4-0.992 8.992-2.016-4.992 0.992-8.992 2.016z m-244-168.992h-107.008q-15.008 0-24.992 10.496t-10.016 24.992 10.016 24.992 24.992 10.496h107.008q14.016 0 24.512-10.496t10.496-24.992-10.496-24.992-24.512-10.496z m107.008-111.008h-214.016q-14.016 0-24.512 10.496t-10.496 24.992 10.496 24.992 24.512 10.496h214.016q14.016 0 24-10.496t10.016-24.992-10.016-24.992-24-10.496z m-240.992 36q0 4 0.992 8-0.992-4-0.992-8zM700 512z m12 52l4-2.016z m-260.992-135.488q0 14.496 10.496 24.992t24.512 10.496h214.016q14.016 0 24-10.496t10.016-24.992-10.016-24.992-24-10.496h-214.016q-14.016 0-24.512 10.496t-10.496 24.992z m8 1.504z"></path>
  4151.                             </svg>
  4152.                         </div>
  4153.                         <div class="cookie-item-group-control-edit">
  4154.                             <svg t="1742795710451" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" width="16" height="16">
  4155.                                 <path d="M800 960 224 960c-52.928 0-96-43.072-96-96L128 224c0-52.928 43.072-96 96-96l448 0c17.696 0 32 14.336 32 32s-14.304 32-32 32L224 192C206.368 192 192 206.368 192 224l0 640c0 17.664 14.368 32 32 32l576 0c17.664 0 32-14.336 32-32L832 352c0-17.664 14.304-32 32-32s32 14.336 32 32l0 512C896 916.928 852.928 960 800 960zM612 448c-8.192 0-16.384-3.136-22.624-9.376-12.512-12.512-12.512-32.736 0-45.248l318.016-318.016c12.512-12.512 32.736-12.512 45.248 0s12.512 32.736 0 45.248l-318.016 318.016C628.384 444.896 620.192 448 612 448zM480 448 288 448c-17.664 0-32-14.336-32-32s14.336-32 32-32l192 0c17.664 0 32 14.336 32 32S497.664 448 480 448zM672 640 288 640c-17.664 0-32-14.304-32-32s14.336-32 32-32l384 0c17.696 0 32 14.304 32 32S689.696 640 672 640z"></path>
  4156.                             </svg>
  4157.                         </div>
  4158.                         <div class="cookie-item-group-control-delete">
  4159.                             ${__pops.config.iconSVG.delete}
  4160.                         </div>
  4161.                     </div>
  4162.                 `
  4163.           )
  4164.         });
  4165.         let $cookieItemCopy = $cookieItemGroupControl.querySelector(
  4166.           ".cookie-item-group-control-copy"
  4167.         );
  4168.         let $cookieItemEdit = $cookieItemGroupControl.querySelector(
  4169.           ".cookie-item-group-control-edit"
  4170.         );
  4171.         let $cookieItemDelete = $cookieItemGroupControl.querySelector(
  4172.           ".cookie-item-group-control-delete"
  4173.         );
  4174.         domUtils.on($cookieItemCopy, "click", (event) => {
  4175.           utils.preventEvent(event);
  4176.           let cookieText = cookieInfo.value;
  4177.           utils.setClip(cookieText).then((status) => {
  4178.             if (status) {
  4179.               Qmsg.success("复制成功");
  4180.             } else {
  4181.               Qmsg.error("复制失败");
  4182.             }
  4183.           });
  4184.         });
  4185.         domUtils.on($cookieItemEdit, "click", (event) => {
  4186.           utils.preventEvent(event);
  4187.           CookieManagerEditView.showView(cookieInfo, (__cookieInfo__) => {
  4188.             let $newCookieItem = createCookieItemElement(__cookieInfo__);
  4189.             domUtils.after($cookieItem, $newCookieItem);
  4190.             $cookieItem.parentElement?.removeChild($cookieItem);
  4191.           });
  4192.         });
  4193.         domUtils.on($cookieItemDelete, "click", (event) => {
  4194.           utils.preventEvent(event);
  4195.           let result = confirm("确定删除该Cookie？");
  4196.           if (!result) {
  4197.             return;
  4198.           }
  4199.           CookieManager.deleteCookie(cookieInfo).then((status) => {
  4200.             if (!status) {
  4201.               Qmsg.success("删除成功");
  4202.               $cookieItem.parentElement?.removeChild($cookieItem);
  4203.             } else {
  4204.               log.error(status);
  4205.               Qmsg.error("删除失败");
  4206.             }
  4207.           });
  4208.         });
  4209.         domUtils.append($cookieItem, [$cookieItemGroupControl]);
  4210.         return $cookieItem;
  4211.       };
  4212.       let updateCookieListGroup = async (filterCallBack) => {
  4213.         let cookieList = await CookieManager.queryAllCookie();
  4214.         domUtils.empty($cookieListWrapper);
  4215.         let $fragment = document.createDocumentFragment();
  4216.         let excludeSessionCookie = Panel.getValue("exclude-session-cookie");
  4217.         cookieList.forEach((cookieInfo) => {
  4218.           if (excludeSessionCookie) {
  4219.             if (cookieInfo.session) {
  4220.               return;
  4221.             }
  4222.             if (CookieManager.cookieManagerApiName === "cookieStore" && cookieInfo.expires == null) {
  4223.               return;
  4224.             }
  4225.           }
  4226.           if (typeof filterCallBack === "function") {
  4227.             let filterResult = filterCallBack(cookieInfo);
  4228.             if (!filterResult) {
  4229.               return;
  4230.             }
  4231.           }
  4232.           const $cookieItem = createCookieItemElement(cookieInfo);
  4233.           $fragment.appendChild($cookieItem);
  4234.         });
  4235.         this.$data.cookieList = cookieList;
  4236.         $cookieListWrapper.appendChild($fragment);
  4237.       };
  4238.       domUtils.on(
  4239.         $search,
  4240.         ["input", "propertychange"],
  4241.         utils.debounce((event) => {
  4242.           let searchText = domUtils.val($search);
  4243.           let isNotFilter = searchText.trim() === "";
  4244.           let enableRegExp = Panel.getValue("search-config-use-regexp");
  4245.           updateCookieListGroup((cookieItem) => {
  4246.             if (isNotFilter) {
  4247.               return true;
  4248.             }
  4249.             return enableRegExp ? Boolean(cookieItem.name.match(new RegExp(searchText))) : cookieItem.name.includes(searchText);
  4250.           });
  4251.         })
  4252.       );
  4253.       domUtils.listenKeyboard($search, "keypress", (keyName, keyValue, otherCodeList) => {
  4254.         if (keyName === "Enter" && otherCodeList.length === 0) {
  4255.           triggerUpdateCookieListGroupWithSearchFilter();
  4256.         }
  4257.       });
  4258.       domUtils.on($searchSetting, "click", (event) => {
  4259.         utils.preventEvent(event);
  4260.         let $settingAlert = __pops.alert({
  4261.           title: {
  4262.             text: "搜索配置",
  4263.             position: "center"
  4264.           },
  4265.           content: {
  4266.             text: "",
  4267.             html: true
  4268.           },
  4269.           btn: {
  4270.             ok: {
  4271.               enable: false
  4272.             }
  4273.           },
  4274.           drag: true,
  4275.           mask: {
  4276.             clickEvent: {
  4277.               toClose: true
  4278.             }
  4279.           },
  4280.           width: PanelUISize.info.width,
  4281.           height: PanelUISize.info.height,
  4282.           style: (
  4283.             /*css*/
  4284.             `
  4285.                     ${__pops.config.cssText.panelCSS}
  4286.  
  4287.                     .pops-alert-content li{
  4288.                         display: flex;
  4289.                         justify-content: space-between;
  4290.                         align-items: center;
  4291.                         padding: 10px;
  4292.                     }
  4293.                     .pops-panel-item-left-desc-text{
  4294.                         line-height: normal;
  4295.                         margin-top: 6px;
  4296.                         font-size: 0.8em;
  4297.                         color: rgb(108, 108, 108);
  4298.                     }
  4299.                 `
  4300.           )
  4301.         });
  4302.         let $content = $settingAlert.$shadowRoot.querySelector(".pops-alert-content");
  4303.         let panelHandlerComponents = __pops.config.PanelHandlerComponents();
  4304.         let $useRegExp = panelHandlerComponents.createSectionContainerItem_switch(
  4305.           UISwitch(
  4306.             "启用正则表达式",
  4307.             "search-config-use-regexp",
  4308.             false,
  4309.             void 0,
  4310.             "使用正则表达式搜索Cookie名称",
  4311.             () => {
  4312.               triggerUpdateCookieListGroupWithSearchFilter();
  4313.             }
  4314.           )
  4315.         );
  4316.         domUtils.append($content, $useRegExp);
  4317.       });
  4318.       domUtils.on($refresh, "click", (event) => {
  4319.         utils.preventEvent(event);
  4320.         triggerUpdateCookieListGroupWithSearchFilter();
  4321.       });
  4322.       domUtils.on($add, "click", (event) => {
  4323.         utils.preventEvent(event);
  4324.         CookieManagerEditView.showView(void 0, (__cookieInfo__) => {
  4325.           triggerUpdateCookieListGroupWithSearchFilter();
  4326.         });
  4327.       });
  4328.       domUtils.on($export, "click", async (event) => {
  4329.         utils.preventEvent(event);
  4330.         CookieBackUpManager.showExportDialog();
  4331.       });
  4332.       domUtils.on($import, "click", async (event) => {
  4333.         utils.preventEvent(event);
  4334.         CookieBackUpManager.showImportDialog();
  4335.       });
  4336.       domUtils.on($clearAll, "click", async (event) => {
  4337.         utils.preventEvent(event);
  4338.         let result = window.confirm("确定清除全部Cookie？");
  4339.         if (!result) {
  4340.           return;
  4341.         }
  4342.         const deleteInfo = await CookieManager.deleteAllCookie();
  4343.         if (deleteInfo.error) {
  4344.           Qmsg.warning(`清除成功：${deleteInfo.success} 失败：${deleteInfo.error}`);
  4345.         } else {
  4346.           Qmsg.success("清除成功");
  4347.         }
  4348.         triggerUpdateCookieListGroupWithSearchFilter();
  4349.       });
  4350.       domUtils.on($ruleManager, "click", (event) => {
  4351.         utils.preventEvent(event);
  4352.         CookieRule.showView();
  4353.       });
  4354.       domUtils.on($setting, "click", (event) => {
  4355.         utils.preventEvent(event);
  4356.         let $settingAlert = __pops.alert({
  4357.           title: {
  4358.             text: "设置",
  4359.             position: "center"
  4360.           },
  4361.           content: {
  4362.             text: "",
  4363.             html: true
  4364.           },
  4365.           btn: {
  4366.             ok: {
  4367.               enable: false
  4368.             }
  4369.           },
  4370.           drag: true,
  4371.           mask: {
  4372.             clickEvent: {
  4373.               toClose: true
  4374.             }
  4375.           },
  4376.           width: PanelUISize.settingMiddle.width,
  4377.           height: PanelUISize.settingMiddle.height,
  4378.           style: (
  4379.             /*css*/
  4380.             `
  4381.                     ${__pops.config.cssText.panelCSS}
  4382.  
  4383.                     .pops-alert-content li{
  4384.                         display: flex;
  4385.                         justify-content: space-between;
  4386.                         align-items: center;
  4387.                         padding: 10px;
  4388.                     }
  4389.                     .pops-panel-item-left-desc-text{
  4390.                         line-height: normal;
  4391.                         margin-top: 6px;
  4392.                         font-size: 0.8em;
  4393.                         color: rgb(108, 108, 108);
  4394.                     }
  4395.                 `
  4396.           )
  4397.         });
  4398.         let $content = $settingAlert.$shadowRoot.querySelector(".pops-alert-content");
  4399.         let panelHandlerComponents = __pops.config.PanelHandlerComponents();
  4400.         let $useGM_cookie = panelHandlerComponents.createSectionContainerItem_select(
  4401.           UISelect(
  4402.             "CookieManager Api",
  4403.             "cookie-manager-api",
  4404.             "document.cookie",
  4405.             CookieManagerApiNameList.map((it) => {
  4406.               return {
  4407.                 text: it,
  4408.                 value: it
  4409.               };
  4410.             }),
  4411.             void 0,
  4412.             "操作Cookie的Api函数",
  4413.             (event2) => {
  4414.               triggerUpdateCookieListGroupWithSearchFilter();
  4415.             }
  4416.           )
  4417.         );
  4418.         let $decodeValue = panelHandlerComponents.createSectionContainerItem_switch(
  4419.           UISwitch(
  4420.             "解码Cookie值",
  4421.             "decode-cookie-value",
  4422.             false,
  4423.             () => {
  4424.               triggerUpdateCookieListGroupWithSearchFilter();
  4425.             },
  4426.             "对Cookie值进行解码"
  4427.           )
  4428.         );
  4429.         let $excludeSessionCookie = panelHandlerComponents.createSectionContainerItem_switch(
  4430.           UISwitch(
  4431.             "排除Session Cookie",
  4432.             "exclude-session-cookie",
  4433.             false,
  4434.             () => {
  4435.               triggerUpdateCookieListGroupWithSearchFilter();
  4436.             },
  4437.             "过滤掉浏览器会话Cookie"
  4438.           )
  4439.         );
  4440.         domUtils.append($content, [$useGM_cookie, $decodeValue, $excludeSessionCookie]);
  4441.       });
  4442.       let triggerUpdateCookieListGroupWithSearchFilter = () => {
  4443.         domUtils.trigger($search, "input");
  4444.       };
  4445.       triggerUpdateCookieListGroupWithSearchFilter();
  4446.     },
  4447.     /**
  4448.      * 注册(不可用)脚本菜单
  4449.      */
  4450.     registerMenu() {
  4451.       const that = this;
  4452.       GM_Menu.add({
  4453.         key: "cookie_manager_view",
  4454.         text: "⚙ Cookie管理",
  4455.         autoReload: false,
  4456.         isStoreValue: false,
  4457.         showText(text, enable) {
  4458.           return text;
  4459.         },
  4460.         callback(data) {
  4461.           that.showView();
  4462.         }
  4463.       });
  4464.     }
  4465.   };
  4466.   const CookieRuleController = {
  4467.     init() {
  4468.       this.execController();
  4469.       domUtils.ready(() => {
  4470.         this.execController();
  4471.       });
  4472.     },
  4473.     /**
  4474.      * 执行cookie规则处理操作
  4475.      */
  4476.     async execController() {
  4477.       for (let index = 0; index < CookieRule.$data.matchedRuleList.length; index++) {
  4478.         const cookieRuleItem = CookieRule.$data.matchedRuleList[index];
  4479.         const operationMode = cookieRuleItem.data.operationMode;
  4480.         log.success(`执行规则：${cookieRuleItem.name}`);
  4481.         let apiName = cookieRuleItem.data.execApiName;
  4482.         if (apiName === "use-global") {
  4483.           apiName = void 0;
  4484.         }
  4485.         const cookieManager2 = new CookieManagerService(apiName);
  4486.         const cookieListResult = await cookieManager2.queryAllCookie();
  4487.         for (let cookieInfoIndex = 0; cookieInfoIndex < cookieListResult.length; cookieInfoIndex++) {
  4488.           let cookieInfo = cookieListResult[cookieInfoIndex];
  4489.           const cookieName = cookieInfo.name;
  4490.           const ruleCookieName = cookieRuleItem.data.cookieName;
  4491.           let flag = false;
  4492.           if (cookieRuleItem.data.enableRegExpToMatchCookieName) {
  4493.             let regExpCookieName = new RegExp(ruleCookieName, "i");
  4494.             if (regExpCookieName.test(cookieName)) {
  4495.               flag = true;
  4496.             }
  4497.           } else {
  4498.             if (cookieName.includes(ruleCookieName)) {
  4499.               flag = true;
  4500.             }
  4501.           }
  4502.           if (flag) {
  4503.             if (operationMode === "delete") {
  4504.               cookieManager2.deleteCookie(cookieInfo);
  4505.             } else if (operationMode.startsWith("extended")) {
  4506.               let currentTime = Date.now();
  4507.               let oneMonth = 30 * 24 * 60 * 60 * 1e3;
  4508.               let threeMonth = oneMonth * 3;
  4509.               let halfAYear = oneMonth * 6;
  4510.               let oneYear = oneMonth * 12;
  4511.               let checkTime = oneMonth;
  4512.               if (operationMode === "extended-90") {
  4513.                 checkTime = threeMonth;
  4514.               } else if (operationMode === "extended-180") {
  4515.                 checkTime = halfAYear;
  4516.               } else if (operationMode === "extended-360") {
  4517.                 checkTime = oneYear;
  4518.               }
  4519.               let updateFlag = false;
  4520.               if (cookieManager2.cookieManagerApiName === "document.cookie") {
  4521.                 cookieInfo.expirationDate = currentTime + checkTime;
  4522.                 updateFlag = true;
  4523.               } else if (cookieManager2.cookieManagerApiName === "cookieStore") {
  4524.                 let expireTime = cookieInfo.expires;
  4525.                 if (typeof expireTime === "number" && expireTime - currentTime < checkTime) {
  4526.                   cookieInfo.expires = expireTime + checkTime;
  4527.                   updateFlag = true;
  4528.                 }
  4529.               } else if (cookieManager2.cookieManagerApiName === "GM_cookie" || cookieManager2.cookieManagerApiName === "GM.cookie") {
  4530.                 let expireTime = cookieInfo.expirationDate;
  4531.                 if (typeof expireTime === "number" && expireTime * 1e3 - currentTime < checkTime) {
  4532.                   cookieInfo.expirationDate = expireTime + checkTime / 1e3;
  4533.                   updateFlag = true;
  4534.                 }
  4535.               } else {
  4536.                 log.error(
  4537.                   "未知的cookieManagerApiName",
  4538.                   cookieManager2.cookieManagerApiName
  4539.                 );
  4540.               }
  4541.               if (updateFlag) {
  4542.                 await cookieManager2.updateCookie(cookieInfo);
  4543.               }
  4544.             }
  4545.           }
  4546.         }
  4547.       }
  4548.     }
  4549.   };
  4550.   const UIButton = function(text, description, buttonText, buttonIcon, buttonIsRightIcon, buttonIconIsLoading, buttonType, clickCallBack, afterAddToUListCallBack, disable) {
  4551.     let result = {
  4552.       text,
  4553.       type: "button",
  4554.       attributes: {},
  4555.       props: {},
  4556.       description,
  4557.       buttonIcon,
  4558.       buttonIsRightIcon,
  4559.       buttonIconIsLoading,
  4560.       buttonType,
  4561.       buttonText,
  4562.       callback(event) {
  4563.         if (typeof clickCallBack === "function") {
  4564.           clickCallBack(event);
  4565.         }
  4566.       },
  4567.       afterAddToUListCallBack
  4568.     };
  4569.     Reflect.set(result.attributes, ATTRIBUTE_INIT, () => {
  4570.       result.disable = Boolean(
  4571.         disable
  4572.       );
  4573.     });
  4574.     return result;
  4575.   };
  4576.   const Component_Rule = {
  4577.     id: "view-rule",
  4578.     title: "规则",
  4579.     headerTitle: "Cookie操作规则",
  4580.     forms: [
  4581.       {
  4582.         type: "forms",
  4583.         text: "",
  4584.         forms: [
  4585.           UIButton(
  4586.             "自定义规则",
  4587.             "操作Cookie的规则",
  4588.             "管理",
  4589.             void 0,
  4590.             false,
  4591.             false,
  4592.             "default",
  4593.             () => {
  4594.               CookieRule.showView();
  4595.             }
  4596.           )
  4597.         ]
  4598.       },
  4599.       {
  4600.         type: "forms",
  4601.         text: "",
  4602.         forms: [
  4603.           UIButton(
  4604.             "数据导入",
  4605.             "导入自定义规则数据",
  4606.             "导入",
  4607.             void 0,
  4608.             false,
  4609.             false,
  4610.             "primary",
  4611.             () => {
  4612.               CookieRule.importRule();
  4613.             }
  4614.           ),
  4615.           UIButton(
  4616.             "数据导出",
  4617.             "导出自定义规则数据",
  4618.             "导出",
  4619.             void 0,
  4620.             false,
  4621.             false,
  4622.             "primary",
  4623.             () => {
  4624.               CookieRule.exportRule("CookieManagerRule.json");
  4625.             }
  4626.           )
  4627.         ]
  4628.       }
  4629.     ]
  4630.   };
  4631.   const Component_Common = {
  4632.     id: "view-general",
  4633.     title: "通用",
  4634.     forms: [
  4635.       {
  4636.         text: "Toast配置",
  4637.         type: "forms",
  4638.         forms: [
  4639.           UISelect(
  4640.             "Toast位置",
  4641.             PanelSettingConfig.qmsg_config_position.key,
  4642.             PanelSettingConfig.qmsg_config_position.defaultValue,
  4643.             [
  4644.               {
  4645.                 value: "topleft",
  4646.                 text: "左上角"
  4647.               },
  4648.               {
  4649.                 value: "top",
  4650.                 text: "顶部"
  4651.               },
  4652.               {
  4653.                 value: "topright",
  4654.                 text: "右上角"
  4655.               },
  4656.               {
  4657.                 value: "left",
  4658.                 text: "左边"
  4659.               },
  4660.               {
  4661.                 value: "center",
  4662.                 text: "中间"
  4663.               },
  4664.               {
  4665.                 value: "right",
  4666.                 text: "右边"
  4667.               },
  4668.               {
  4669.                 value: "bottomleft",
  4670.                 text: "左下角"
  4671.               },
  4672.               {
  4673.                 value: "bottom",
  4674.                 text: "底部"
  4675.               },
  4676.               {
  4677.                 value: "bottomright",
  4678.                 text: "右下角"
  4679.               }
  4680.             ],
  4681.             (event, isSelectValue, isSelectText) => {
  4682.               log.info("设置当前Qmsg弹出位置" + isSelectText);
  4683.             },
  4684.             "Toast显示在页面九宫格的位置"
  4685.           ),
  4686.           UISelect(
  4687.             "最多显示的数量",
  4688.             PanelSettingConfig.qmsg_config_maxnums.key,
  4689.             PanelSettingConfig.qmsg_config_maxnums.defaultValue,
  4690.             [
  4691.               {
  4692.                 value: 1,
  4693.                 text: "1"
  4694.               },
  4695.               {
  4696.                 value: 2,
  4697.                 text: "2"
  4698.               },
  4699.               {
  4700.                 value: 3,
  4701.                 text: "3"
  4702.               },
  4703.               {
  4704.                 value: 4,
  4705.                 text: "4"
  4706.               },
  4707.               {
  4708.                 value: 5,
  4709.                 text: "5"
  4710.               }
  4711.             ],
  4712.             void 0,
  4713.             "限制Toast显示的数量"
  4714.           ),
  4715.           UISwitch(
  4716.             "逆序弹出",
  4717.             PanelSettingConfig.qmsg_config_showreverse.key,
  4718.             PanelSettingConfig.qmsg_config_showreverse.defaultValue,
  4719.             void 0,
  4720.             "修改Toast弹出的顺序"
  4721.           )
  4722.         ]
  4723.       }
  4724.     ]
  4725.   };
  4726.   PanelContent.addContentConfig([Component_Common, Component_Rule]);
  4727.   Panel.init();
  4728.   CookieManagerView.init();
  4729.   CookieRule.init();
  4730.   CookieRuleController.init();
  4731.  
  4732. })(Qmsg, DOMUtils, Utils, pops, CryptoJS);

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址