邀您一起看：❤️接口多选测试

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥❤️接口多选测试@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[],\"saved\":false,\"title\":\"聚影外挂\",\"version\":0,\"url\":\"hiker://empty#noRecordHistory#;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\",\"col_type\":\"movie_3_marquee\",\"find_rule\":\"js:(\\n(dx_test, jkpath, color) => {\\n    setPageTitle(dx_test);\\n    addListener(\\\"onClose\\\", $.toString(() => {\\n        refreshPage(false);\\n    }\\n    ));\\n    let d = [];\\n    let jks = JSON.parse(fetch(jkpath) || \\\"[]\\\");\\n    let expand = [\\\"xpath\\\", \\\"biubiu\\\"];\\n    let jxs = jks.filter(it => !expand.includes(it.type));\\n    let data = storage0.getMyVar(\\\"jx_selected\\\") || [];\\n    let dx_filter = getItem(\\\"dx_filter\\\", \\\"\\\\u5168\\\\u90e8\\\");\\n    if (dx_filter === \\\"\\\\u5df2\\\\u9009\\\") {\\n        jxs = jxs.filter(it => data.includes(it.url));\\n    } else {\\n        if (dx_filter === \\\"\\\\u672a\\\\u9009\\\") {\\n            jxs = jxs.filter(it => !data.includes(it.url));\\n        }\\n    }\\n    d = jxs.map((it) => {\\n        return {title: (Array.isArray(data) && data.includes(it.url)) ? color(it.name, \\\"#12b668\\\") : it.name, url: $(\\\"#noLoading#\\\").lazyRule((it, color) => {\\n            let data = storage0.getMyVar(\\\"jx_selected\\\");\\n            if (Array.isArray(data)) {\\n                if (data.includes(it.url)) {\\n                    log(\\\"\\\\u5305\\\\u542b:\\\" + it.url);\\n                    data.splice(data.indexOf(it.url), 1);\\n                } else {\\n                    data.push(it.url);\\n                }\\n                storage0.putMyVar(\\\"jx_selected\\\", data);\\n            } else {\\n                storage0.putMyVar(\\\"jx_selected\\\", [it.url]);\\n            }\\n            if (storage0.getMyVar(\\\"jx_selected\\\").includes(it.url)) {\\n                updateItem(it.url, {title: color(it.name, \\\"#12b668\\\")});\\n            } else {\\n                updateItem(it.url, {title: it.name});\\n            }\\n            return \\\"hiker://empty\\\";\\n        }\\n        , it, color), col_type: \\\"text_3\\\", desc: JSON.stringify(it), extra: {id: it.url}};\\n    }\\n    );\\n    let op = [];\\n    op.push({title: \\\"\\\\u5168\\\\u9009\\\", url: $(\\\"#noLoading#\\\").lazyRule((jxs, color) => {\\n        storage0.putMyVar(\\\"jx_selected\\\", jxs.map(it => it.url));\\n        jxs.forEach(it => {\\n            updateItem({title: color(it.name, \\\"#12b668\\\"), extra: {id: it.url}});\\n        }\\n        );\\n        return \\\"hiker://empty\\\";\\n    }\\n    , jxs, color), col_type: \\\"flex_button\\\"});\\n    op.push({title: \\\"\\\\u5168\\\\u4e0d\\\\u9009\\\", url: $(\\\"#noLoading#\\\").lazyRule((jxs) => {\\n        storage0.putMyVar(\\\"jx_selected\\\", []);\\n        jxs.forEach(it => {\\n            updateItem({title: it.name, extra: {id: it.url}});\\n        }\\n        );\\n        return \\\"hiker://empty\\\";\\n    }\\n    , jxs), col_type: \\\"flex_button\\\"});\\n    op.push({title: \\\"\\\\u53cd\\\\u9009\\\", url: $(\\\"#noLoading#\\\").lazyRule((jxs, color) => {\\n        let oldSel = storage0.getMyVar(\\\"jx_selected\\\", []);\\n        function getDifferentData(arrA, arrB) {\\n            return arrA.concat(arrB).filter(function (v, i, arr) {\\n                return arr.indexOf(v) === arr.lastIndexOf(v);\\n            });\\n        }\\n        let jxSel = jxs.map(it => it.url);\\n        let newSel = getDifferentData(jxSel, oldSel);\\n        storage0.putMyVar(\\\"jx_selected\\\", newSel);\\n        newSel.forEach(it => {\\n            let t = jxs.filter(its => its.url === it)[0];\\n            updateItem(it, {title: color(t.name, \\\"#12b668\\\")});\\n        }\\n        );\\n        oldSel.forEach(it => {\\n            let t = jxs.filter(its => its.url === it)[0];\\n            updateItem(it, {title: t.name});\\n        }\\n        );\\n        return \\\"hiker://empty\\\";\\n    }\\n    , jxs, color), col_type: \\\"flex_button\\\"});\\n    op.push({title: \\\"\\\\u641c\\\\u7d22\\\\u8bcd\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        return $(getMyVar(\\\"skey\\\", \\\"\\\\u6211\\\\u7684\\\"), \\\"\\\\u5f53\\\\u524d\\\\u641c\\\\u7d22\\\\u8bcd\\\").input(() => {\\n            if (input) {\\n                putMyVar(\\\"skey\\\", input);\\n                return \\\"hiker://empty\\\";\\n            }\\n            return \\\"hiker://empty\\\";\\n        }\\n        );\\n    }\\n    ), col_type: \\\"flex_button\\\"});\\n    op.push({title: \\\"\\\\u6d4b\\\\u8bd5\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let sel = storage0.getMyVar(\\\"jx_selected\\\", []);\\n        if (sel.length < 1) {\\n            return \\\"toast://\\\\u5565\\\\u90fd\\\\u6ca1\\\\u9009\\\\uff0c\\\\u6d4b\\\\u8bd5\\\\u4e2a\\\\u9e21\\\\u6bdb~\\\";\\n        }\\n        return $(\\\"\\\\u786e\\\\u8ba4\\\\u6d4b\\\\u8bd5\\\\u5df2\\\\u9009\\\\u62e9\\\\u7684:\\\" + sel[0] + \\\"\\\\u7b49\\\" + sel.length + \\\"\\\\u6761\\\\u63a5\\\\u53e3?\\\").confirm((sel) => {\\n            return $(\\\"hiker://empty\\\").rule((sel) => {\\n                addListener(\\\"onClose\\\", $.toString(() => {\\n                    refreshPage(false);\\n                }\\n                ));\\n                let jkpath = \\\"hiker://files//rules/Src/Juying/jiekou.json\\\";\\n                let jks = JSON.parse(fetch(jkpath) || \\\"[]\\\");\\n                let apijks = jks.filter(it => sel.includes(it.url));\\n                let skey = getMyVar(\\\"skey\\\", \\\"\\\\u6211\\\\u7684\\\");\\n                let d = [];\\n                d.push({title: \\\"\\\\u5220\\\\u9664\\\\u574f\\\\u7684\\\\u63a5\\\\u53e3\\\", col_type: \\\"text_2\\\", url: $().lazyRule(() => {\\n                    let arr = (findItemsByCls(\\\"failed\\\") || []).map((it) => {\\n                        return {id: it.extra.id, name: it.extra.name, url: it.extra.url};\\n                    }\\n                    );\\n                    if (arr.length < 1) {\\n                        return \\\"toast://\\\\u5f88\\\\u68d2,\\\\u5f53\\\\u524d\\\\u6d4b\\\\u8bd5\\\\u7ed3\\\\u679c\\\\u770b\\\\u8d77\\\\u6765\\\\u6ca1\\\\u6709\\\\u574f\\\\u6389\\\\u7684\\\\u63a5\\\\u53e3\\\";\\n                    }\\n                    let tips = arr.map(it => it.name).join(\\\",\\\");\\n                    return $(\\\"\\\\u5f53\\\\u524d\\\\u6d4b\\\\u8bd5\\\\u7ed3\\\\u679c\\\\u5171\\\\u8ba1\\\" + arr.length + \\\"\\\\u4e2a\\\\u7591\\\\u4f3c\\\\u5931\\\\u6548\\\\u7684\\\\u7684\\\\u8d44\\\\u6e90\\\\u63a5\\\\u53e3,\\\\u662f\\\\u5426\\\\u5220\\\\u9664?\\\\n\\\" + tips).confirm((arr) => {\\n                        let jkpath = \\\"hiker://files//rules/Src/Juying/jiekou.json\\\";\\n                        let apijks = JSON.parse(fetch(jkpath) || \\\"[]\\\");\\n                        let deled = [];\\n                        let delurls = [];\\n                        arr.forEach((it) => {\\n                            log(\\\"\\\\u5220\\\\u9664\\\\u63a5\\\\u53e3:\\\" + it.name + \\\",id:\\\" + it.id);\\n                            deled.push(it.name);\\n                            delurls.push(it.url);\\n                        }\\n                        );\\n                        apijks = apijks.filter(its => !delurls.includes(its.url));\\n                        let sel = storage0.getMyVar(\\\"jx_selected\\\", []);\\n                        sel = sel.filter(its => !delurls.includes(its));\\n                        deleteItemByCls(\\\"failed\\\");\\n                        storage0.putMyVar(\\\"jx_selected\\\", sel);\\n                        writeFile(jkpath, JSON.stringify(apijks));\\n                        return \\\"toast://\\\\u5df2\\\\u5220\\\\u9664:\\\" + deled.join(\\\",\\\");\\n                    }\\n                    , arr);\\n                }\\n                )});\\n                d.push({title: \\\"\\\\u67e5\\\\u770b\\\\u574f\\\\u86cb\\\", col_type: \\\"text_2\\\", url: $().lazyRule(() => {\\n                    let arr = (findItemsByCls(\\\"failed\\\") || []).map((it) => {\\n                        return {id: it.id, name: it.extra.name, url: it.extra.url};\\n                    }\\n                    );\\n                    if (arr.length < 1) {\\n                        return \\\"toast://\\\\u5f88\\\\u68d2,\\\\u5f53\\\\u524d\\\\u6d4b\\\\u8bd5\\\\u7ed3\\\\u679c\\\\u770b\\\\u8d77\\\\u6765\\\\u6ca1\\\\u6709\\\\u574f\\\\u6389\\\\u7684\\\\u63a5\\\\u53e3\\\";\\n                    }\\n                    return $(\\\"hiker://empty#noHistory##noRecordHistory#\\\").rule((arr) => {\\n                        setPageTitle(\\\"\\\\u574f\\\\u86cb\\\\u5217\\\\u8868\\\");\\n                        let d = [];\\n                        d.push({title: \\\"\\\\u5171\\\\u8ba1\\\" + arr.length + \\\"\\\\u4e2a\\\\u574f\\\\u86cb\\\", url: \\\"hiker://empty\\\", col_type: \\\"text_1\\\"});\\n                        d.push({title: JSON.stringify(arr), col_type: \\\"long_text\\\"});\\n                        setResult(d);\\n                    }\\n                    , arr);\\n                }\\n                )});\\n                d.push({title: `测试搜索““””<font color=\\\"red\\\">${skey}</font> 结果如下:`, col_type: \\\"text_1\\\", url: \\\"toast://\\\\u770b\\\\u4e0b\\\\u9762\\\\u7684!\\\", extra: {id: \\\"result\\\"}});\\n                setResult(d);\\n                function getKey() {\\n                    let time_str = $.dateFormat(new Date(), \\\"yyyy-MM-dd HH:mm:ss\\\");\\n                    let tmp = time_str.split(\\\" \\\")[0].split(\\\"-\\\");\\n                    return tmp[1] + tmp[2];\\n                }\\n                function isIptv(link) {\\n                    if (/iptv|Chengcheng/.test(link)) {\\n                        return true;\\n                    }\\n                    let special = [\\\"tv.hfys8.vip/api.php/Sntv/vod\\\", \\\"dsxtv.tv.ci/api.php/dsx/vod\\\"];\\n                    for (let url of special) {\\n                        if (link.includes(url)) {\\n                            return true;\\n                        }\\n                    }\\n                    return false;\\n                }\\n                var count = apijks.length;\\n                log(\\\"\\\\u5f00\\\\u542f\\\\u591a\\\\u4efb\\\\u52a1\\\\u6d4b\\\\u8bd5,\\\\u4efb\\\\u52a1\\\\u6570\\\\u91cf:\\\" + count);\\n                var task = function (obj) {\\n                    let surl = obj.surl;\\n                    let ua = obj.ua;\\n                    if (ua === \\\"PC_UA\\\") {\\n                        ua = PC_UA;\\n                    } else {\\n                        if (ua === \\\"MOBILE_UA\\\") {\\n                            ua = MOBILE_UA;\\n                        }\\n                    }\\n                    var html = fetch(surl, {headers: {\\\"User-Agent\\\": ua}, timeout: Number(getMyVar(\\\"timeout\\\", \\\"5000\\\"))}) || \\\"\\\";\\n                    let cls;\\n                    var hm = html.slice(0, 200);\\n                    var ret = {};\\n                    var json = {};\\n                    try {\\n                        ret = JSON.parse(html);\\n                        cls = \\\"success\\\";\\n                        if (obj.v1) {\\n                            json = ret.data.list;\\n                        } else {\\n                            if (obj.v2 || obj.iptv) {\\n                                json = ret.data;\\n                            } else {\\n                                json = ret.list;\\n                            }\\n                        }\\n                        if (Array.isArray(json)) {\\n                            json = json[0];\\n                        }\\n                        ret = json;\\n                        if (obj.name.includes(\\\"\\\\u767d\\\\u4e91\\\")) {\\n                        }\\n                    }\\n                    catch (e) {\\n                        log(obj.name + \\\"\\\\u89e3\\\\u6790\\\\u9519\\\\u8bef:\\\" + e.message);\\n                        cls = \\\"failed\\\";\\n                    }\\n                    return {ret: ret, surl: surl, hm: hm, cls: cls};\\n                };\\n                var parseRet = [];\\n                let tasks = apijks.map((it, idex) => {\\n                    let type = it.type;\\n                    let link = it.url;\\n                    let surl = link + \\\"?wd=\\\" + skey + \\\"&pg=1&ac=list\\\";\\n                    if (type) {\\n                        v1 = type === \\\"v1\\\";\\n                        v2 = type === \\\"v2\\\";\\n                        app = type === \\\"app\\\" || v2;\\n                        iptv = type === \\\"iptv\\\";\\n                    } else {\\n                        v1 = link.includes(\\\".vod\\\");\\n                        v2 = link.includes(\\\"app.php\\\");\\n                        app = link.includes(\\\"/app\\\") || v2;\\n                        iptv = isIptv(link);\\n                    }\\n                    if (v1) {\\n                        surl = surl.replace(\\\"pg=\\\", \\\"limit=20&page=\\\") + \\\"&key=\\\" + getKey();\\n                    } else {\\n                        if (app) {\\n                            surl = link + \\\"/search?pg=1&text=\\\" + skey + \\\"&token=\\\";\\n                        } else {\\n                            if (iptv) {\\n                                surl = link + \\\"/?ac=list&pg=1&wd=\\\" + skey;\\n                            }\\n                        }\\n                    }\\n                    it.surl = surl;\\n                    it.v1 = v1;\\n                    it.v2 = v2;\\n                    it.app = app;\\n                    it.iptv = iptv;\\n                    log(`${it.name} 搜索链接: ${surl},ua:${it.ua},类型:${type}`);\\n                    return {func: task, param: it, id: \\\"task\\\" + idex};\\n                }\\n                );\\n                function sortByKey(array, key, order) {\\n                    return array.sort(function (a, b) {\\n                        var x = parseInt(a[key].match(/(\\\\d+)/)[1]);\\n                        var y = parseInt(b[key].match(/(\\\\d+)/)[1]);\\n                        if (order) {\\n                            return ((x < y) ? -1 : ((x > y) ? 1 : 0));\\n                        } else {\\n                            return ((x < y) ? ((x > y) ? 1 : 0) : -1);\\n                        }\\n                    });\\n                }\\n                be(tasks, {func: function (obj, id, error, ret) {\\n                    let hm = (ret.hm || \\\"\\\").trim();\\n                    let hm1 = hm.slice(0, 10);\\n                    error = error || \\\"\\\";\\n                    let it = tasks.filter(it => it.id === id)[0].param;\\n                    let data = ret.ret || {};\\n                    parseRet.push({task: id, data: data, surl: ret.surl, error: error, it: it});\\n                    count -= 1;\\n                    addItemAfter(\\\"result\\\", {title: data.vod_name || data.title + \\\"\\\\n\\\" + `‘‘’’<small><font color=#f13b66a>${data.vod_remarks || data.state}</font></small>`, pic_url: data.vod_pic || data.pic, desc: `${hm1}\\\\n‘‘’’<font color=#f13b66a>${it.name}</font> (${it.type})`, url: $(\\\"#noLoading#\\\").lazyRule((surl, name, type, id, url) => {\\n                        return $([\\\"\\\\u8bbf\\\\u95ee\\\", \\\"\\\\u5220\\\\u9664\\\"], 2, \\\"\\\\u8bf7\\\\u9009\\\\u62e9\\\\u6267\\\\u884c\\\\u7684\\\\u64cd\\\\u4f5c\\\").select((surl, name, type, url, id) => {\\n                            if (input === \\\"\\\\u8bbf\\\\u95ee\\\") {\\n                                return surl;\\n                            } else {\\n                                if (input === \\\"\\\\u5220\\\\u9664\\\") {\\n                                    log(\\\"\\\\u5220\\\\u9664\\\\u63a5\\\\u53e3:\\\" + name + \\\"(\\\" + type + \\\"),id:\\\" + id);\\n                                    deleteItem([id]);\\n                                    let jkpath = \\\"hiker://files//rules/Src/Juying/jiekou.json\\\";\\n                                    let jks = JSON.parse(fetch(jkpath) || \\\"[]\\\");\\n                                    let apijks = jks.filter(it => !(it.url === url));\\n                                    writeFile(jkpath, JSON.stringify(apijks));\\n                                    let sel = storage0.getMyVar(\\\"jx_selected\\\", []);\\n                                    let idex = sel.findIndex(it => it === url);\\n                                    if (idex > -1) {\\n                                        sel.splice(idex, 1);\\n                                        storage0.putMyVar(\\\"jx_selected\\\", sel);\\n                                    }\\n                                    return \\\"toast://\\\\u5df2\\\\u5220\\\\u9664:\\\" + name;\\n                                }\\n                            }\\n                        }\\n                        , surl, name, type, url, id);\\n                    }\\n                    , ret.surl, it.name, it.type, id, it.url), col_type: \\\"movie_1_vertical_pic\\\", extra: {id: id, ua: it.ua, hm: hm, cls: ret.cls, url: it.url, name: it.name}});\\n                }, param: {hi: \\\"ccc\\\"}});\\n            }\\n            , sel);\\n        }\\n        , sel);\\n    }\\n    ), col_type: \\\"flex_button\\\"});\\n    op.push({title: \\\"\\\\u4fee\\\\u6539\\\", col_type: \\\"flex_button\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let sel = storage0.getMyVar(\\\"jx_selected\\\", []);\\n        if (sel.length < 1) {\\n            return \\\"toast://\\\\u5565\\\\u90fd\\\\u6ca1\\\\u9009\\\\uff0c\\\\u4fee\\\\u6539\\\\u4e2a\\\\u9e21\\\\u6bdb~\\\";\\n        }\\n        if (sel.length !== 1) {\\n            return \\\"toast://\\\\u805a\\\\u5f71\\\\u5b98\\\\u65b9\\\\u672a\\\\u63d0\\\\u4f9b\\\\u6279\\\\u91cf\\\\u4fee\\\\u6539\\\\u63a5\\\\u53e3\\\\uff0c\\\\u76ee\\\\u524d\\\\u53ea\\\\u5141\\\\u8bb8\\\\u5355\\\\u4e2a\\\\u4fee\\\\u6539\\\\uff0c\\\\u5c3d\\\\u60c5\\\\u8c05\\\\u89e3~\\\";\\n        }\\n        let data = JSON.parse(findItem(sel[0]).desc || \\\"{}\\\");\\n        return $(\\\"hiker://empty#noRecordHistory##noHistory#\\\").rule((data) => {\\n            require(config.依赖.match(/https.*\\\\//)[0] + \\\"SrcJySet.js\\\");\\n            jiekou(\\\"update\\\", data);\\n        }\\n        , data);\\n    }\\n    )});\\n    op.push({title: \\\"\\\\u5220\\\\u9664\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let sel = storage0.getMyVar(\\\"jx_selected\\\", []);\\n        if (sel.length < 1) {\\n            return \\\"toast://\\\\u5565\\\\u90fd\\\\u6ca1\\\\u9009\\\\uff0c\\\\u5220\\\\u9664\\\\u4e2a\\\\u9e21\\\\u6bdb~\\\";\\n        }\\n        return $(\\\"\\\\u786e\\\\u8ba4\\\\u5220\\\\u9664\\\\u5df2\\\\u9009\\\\u62e9\\\\u7684:\\\" + sel[0] + \\\"\\\\u7b49\\\" + sel.length + \\\"\\\\u6761\\\\u63a5\\\\u53e3?\\\").confirm((sel) => {\\n            let jkpath = \\\"hiker://files//rules/Src/Juying/jiekou.json\\\";\\n            let jks = JSON.parse(fetch(jkpath) || \\\"[]\\\");\\n            let expand = [\\\"xpath\\\", \\\"biubiu\\\"];\\n            let apijks = jks.filter(it => !sel.includes(it.url));\\n            writeFile(jkpath, $.stringify(apijks));\\n            storage0.putMyVar(\\\"jx_selected\\\", []);\\n            refreshPage(false);\\n            return \\\"toast://\\\\u5df2\\\\u5c06\\\\u3016\\\" + sel[0] + \\\"\\\\u3017\\\\u7b49\\\" + sel.length + \\\"\\\\u6761\\\\u63a5\\\\u53e3\\\\u5220\\\\u9664\\\";\\n        }\\n        , sel);\\n    }\\n    ), col_type: \\\"flex_button\\\"});\\n    op.push({title: \\\"\\\\u64cd\\\\u4f5c|\\\\u7b5b\\\\u9009 \\\" + color(jxs.length, \\\"#ff7000\\\"), url: \\\"toast://\\\\u524d\\\\u9762\\\\u6309\\\\u94ae\\\\u662f\\\\u64cd\\\\u4f5c\\\\uff0c\\\\u540e\\\\u9762\\\\u6309\\\\u94ae\\\\u662f\\\\u7b5b\\\\u9009\\\", col_type: \\\"scroll_button\\\"});\\n    op.push({title: dx_filter === \\\"\\\\u5168\\\\u90e8\\\" ? color(\\\"\\\\u5168\\\\u90e8\\\", \\\"#12b668\\\") : \\\"\\\\u5168\\\\u90e8\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        setItem(\\\"dx_filter\\\", \\\"\\\\u5168\\\\u90e8\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }\\n    ), col_type: \\\"scroll_button\\\"});\\n    op.push({title: dx_filter === \\\"\\\\u5df2\\\\u9009\\\" ? color(\\\"\\\\u5df2\\\\u9009\\\", \\\"#12b668\\\") : \\\"\\\\u5df2\\\\u9009\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        setItem(\\\"dx_filter\\\", \\\"\\\\u5df2\\\\u9009\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }\\n    ), col_type: \\\"scroll_button\\\"});\\n    op.push({title: dx_filter === \\\"\\\\u672a\\\\u9009\\\" ? color(\\\"\\\\u672a\\\\u9009\\\", \\\"#12b668\\\") : \\\"\\\\u672a\\\\u9009\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        setItem(\\\"dx_filter\\\", \\\"\\\\u672a\\\\u9009\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }\\n    ), col_type: \\\"scroll_button\\\"});\\n    d = op.concat(d);\\n    setResult(d);\\n}\\n)(\\\"❤️接口多选测试\\\",\\\"hiker://files//rules/Src/Juying/jiekou.json\\\",\\nfunction (text, color) {\\n    text += \\\"\\\";\\n    if (text.indexOf(\\\"\\\\u201c\\\\u201c\\\\u201d\\\\u201d\\\") === 0) {\\n        text.replace(\\\"\\\\u201c\\\\u201c\\\\u201d\\\\u201d\\\", \\\"\\\");\\n    }\\n    return \\\"\\\\u201c\\\\u201c\\\\u201d\\\\u201d<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n}\\n)\",\"group\":\"工具\",\"ua\":\"mobile\",\"preRule\":\"initConfig({\\n    依赖: \\\"https://gitcode.net/src48597962/hk/-/raw/master/SrcJuying.js\\\"\\n});\\n//by.帅√`人才 聚影模板！\",\"pages\":\"[]\"}","title":"❤️接口多选测试"}