首頁 探索 說明
登入
jiku88888
/
hiker
镜像来自 https://github.com/qiusunshine/hiker-rules
關註 1
讚好 0
複刻 0
Files 問題管理 0 Wiki
目錄樹: 9c413fdb40
分支列表 標籤列表
hiker
/
rules
/
24-5-4-云简搜索引擎规则「97」条.txt

24-5-4-云简搜索引擎规则「97」条.txt 117 KB
文件歷史 原始文件

1 
  1. 海阔视界云简搜索引擎，共「97」条，复制整条口令打开软件就会自动导入$[{"name":"video","author":"","find":"let url = \"https://video.451024.xyz/api/mv\";\nlet json = post(url, {\n    headers: {\n        Referer: \"https://video.451024.xyz/video?name=\" + s\n    },\n    body: JSON.stringify({\n        \"k\": s,\n        \"n\": (page - 1)\n    })\n});\njson = JSON.parse(json);\nlet list = json.data;\nlet d = [];\nfor (let j of list) {\n    d.push({\n        title: j.title,\n        desc: j.link,\n        //pic_url: ,\n        url: j.link\n    })\n}\nreturn d;","basicUrl":"","findAliUrl":"","page":true,"lastModify":1715674920551,"group":"综合","ruleType":""},{"name":"懒盘搜索","author":"zhao","find":"function gethtml() {\n    let html = request(\"https://www.lzpanx.com/search?exact=false&page=\" + page + \"&q=\" + s + \"&share_time=&type=&user=\", );\n    return html;\n};\nvar html = gethtml();\n\nlet list = pdfa(html, \"body&&._search-item-head_12qtj_24\");\nlet d = [];\nfor (let it of list) {\n    d.push({\n        title: pdfh(it, \"a&&title\"),\n        url: basicUrl+pdfh(it, \"a&&href\")\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"let html = request(input);\n\nlet arr = pdfa(html, \"body&&.thread-content\").map(v => pdfh(v, \"a&&href\")).filter(v => v.includes(\"ali\") || v.includes(\"quark\"));\nif (arr.length === 0) {\n    return input;\n} else {\n    return arr;\n}","page":true,"lastModify":1712816304557,"group":"综合","ruleType":""},{"name":"小宇搜索","author":"zhao","find":"function gethtml() {\n    let html = request(\"http://dm.xiaouj.cn/?s=\" + encodeURIComponent(s) + \"&paged=\" + page, );\n    return html;\n};\nvar html = gethtml();\n\nlet list = pdfa(html, \"body&&.post\");\nlet d = [];\nfor (let it of list) {\n    d.push({\n        title: pdfh(it, \"h2&&Text\") + pdfh(it, \"h1&&Text\"),\n        url: basicUrl+pdfh(it, \"a&&href\"),\n        pic_url: pdfh(it, \"img&&src\"),\n        desc: pdfh(it, \"p&&Text\"),\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"let html = request(input);\n\nlet arr = pdfa(html, '.entry-content&&a:not([href*=\"dm.xiaouj.cn\"])').map(v => pdfh(v, \"a&&href\")).filter(v => v.includes(\"ali\") || v.includes(\"quark\"));\nif (arr.length === 0) {\n    return input;\n} else {\n    return arr;\n}","page":true,"lastModify":1712810033085,"group":"综合","ruleType":""},{"name":"奇乐搜","author":"@LoyDgIk","find":".list-group&&.list-group-item\nh2&&Text\na&&href","basicUrl":"https://www.qileso.com/page/fypage?s=**","findAliUrl":"#body&&.thread-content&&p,-1&&a&&href","page":true,"lastModify":1712589297292,"group":"综合","ruleType":"HTML"},{"name":"升维短剧","author":"@LoyDgIk","find":"let data = JSON.parse(fetch(basicUrl+\"/api/search_video/\"+encodeURIComponent(s)));\n\nreturn data.data.map(v=>({\n    title: v.ServerFilename,\n    desc: v.UpdatedAt,\n    url: String(v.FID)\n}));","basicUrl":"http://dj.swkj22.cn","findAliUrl":"let data = JSON.parse(fetch(basicUrl + \"/api/get_video_episode/\" + input));\nreturn new EasyNextPage(data.data.sort((a, b) => parseInt(a.ServerFilename.replace(/视频/, '')) - parseInt(b.ServerFilename.replace(/视频/, ''))).map(v => {\n    return {\n        aliUrl: JSON.stringify({\n            urls: [basicUrl + \"/api/user/get_m3u8_by_fid/\" + input + \"/\" + v.FID + \".m3u8\"],\n            headers: [{\n                \"Cookie\": \"session=MTcxNDYyMzcxMXxEWDhFQVFMX2dBQUJFQUVRQUFCOF80QUFCQVp6ZEhKcGJtY01DUUFIYzIxelkyOWtaUU5wYm5RRUJBRC1MLUFHYzNSeWFXNW5EQWtBQjJsemJHOW5hVzRFWW05dmJBSUNBQUVHYzNSeWFXNW5EQVFBQW1sa0JIVnBiblFHQkFELUF6OEdjM1J5YVc1bkRBb0FDSFZ6WlhKdVlXMWxCbk4wY21sdVp3d05BQXN4TlRjMk9EUXlNRGcwTmc9PXy6dILyqpEiObrjsZ1-PWlwQrv6VhYEzv-hxA55nBKiiw==\",\n                \"User-Agent\": \"Mozilla/5.0 (Linux; Android 12; 22021211RC Build/SKQ1.211006.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/99.0.4844.88 Mobile Safari/537.36\"\n            }]\n        }),\n        title: v.ServerFilename.replace(/视频/, ''),\n    };\n}), \"text_3\");\n\n","page":false,"lastModify":1714635193335,"group":"综合","ruleType":""},{"name":"秒搜","author":"@LoyDgIk","find":"let json = JSON.parse(request(basicUrl + \"/api/secendsearch?name=\" + encodeURIComponent(s) + \"&pageNo=\" + page));\nlet CryptoUtil = $.require(\"hiker://assets/crypto-java.js\");\nlet key = CryptoUtil.Data.parseUTF8(\"4OToScUFOaeVTrHE\");\nlet iv = CryptoUtil.Data.parseUTF8(\"9CLGao1vHKqm17Oz\");\n\nfunction decrypt(data) {\n    return CryptoUtil.AES.decrypt(data, key, {\n        iv,\n        mode: \"AES/CBC/PKCS7Padding\"\n    }).toString();\n}\nlet list = json.data.list;\nreturn list.map(v => ({\n    title: v.name,\n    url: decrypt(v.url),\n    desc: v.gmtCreate + \" \" + v.from\n}));","basicUrl":"https://miaosou.fun","findAliUrl":"","page":true,"lastModify":1711201134107,"group":"综合","ruleType":""},{"name":"51panso","author":"@LoyDgIk","find":"let data = JSON.parse(post(basicUrl + \"/v1/search/disk\", {\n    body: JSON.stringify({\n        \"page\": page,\n        \"size\": 10,\n        \"q\": s,\n        \"type\": \"\",\n        \"share_time\": \"\"\n    })\n})).data.list;\nlet d = [];\nfor (let it of data) {\n    d.push({\n        title: it.disk_name,\n        url: it.link,\n        desc: it.shared_time + \"\\n\" + it.link\n    });\n}\nreturn d;","basicUrl":"http://51yunpan.com","findAliUrl":"","page":true,"lastModify":1710764735454,"group":"综合"},{"name":"云盘4k","find":"let url = \"https://www.codelicence.cn/search\";\nlet redirectUrl = JSON.parse(post(url, {\n    headers: {\n        Referer: \"https://www.codelicence.cn\"\n    },\n    body: {\n        'keyboard': s,\n    },\n    redirect: false,\n    withHeaders: true,\n})).headers.location[0];\n\n\nlet searchUrl = redirectUrl + \"?p=\" + page;\nlet html = request(searchUrl);\nlet arr = parseDomForArray(html, \"body&&.list&&ul\");\nlet d = [];\n\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let utitle = parseDomForHtml(it, \"a&&Text\");\n    let userial = parseDomForHtml(it, \"li&&data_size\");\n    let u = parseDom(it, \"a&&href\", \"https://www.codelicence.cn/\");\n    d.push({\n        title: utitle,\n        url: u,\n        desc: userial\n    });\n}\n\nreturn d;","basicUrl":"","findAliUrl":"let host=getHome(input);\nlet urlred=host+pdfh(request(input),\".down&&a&&href\");\n\nlet headers = {\n    \"sec-ch-ua\": 'Chromium\";v=\"118\", \"Android WebView\";v=\"118\", \"Not=A?Brand\";v=\"99\"',\n    \"sec-ch-ua-mobile\": \"?1\",\n    \"Accept\": \"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7\",\n    \"Upgrade-Insecure-Requests\": \"1 \",\n    \"sec-ch-ua-platform\": \"Android\",\n    \"User-Agent\": MOBILE_UA,\n    \"Host\": host.split(\"//\")[1],\n    \"Connection\": \"Keep-Alive\",\n    \"Accept-Encoding\": \"gzip\",\n    \"Referer\": urlred\n}\n\n\nlet url = JSON.parse(request(urlred, {\n    headers,\n    redirect: false,\n    withHeaders: true\n})).headers.location[0];\nreturn url;","page":true,"lastModify":1714643095755,"group":"综合","author":"","ruleType":""},{"name":"运输车","find":"let url = basicUrl + \"/index.php/vodsearch/\" + s + \"----------\" + page + \"---.html\";\nlet html = request(url);\nlet arr = parseDomForArray(html, \".module-items&&.module-search-item\");\n\nlet bet = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let utitle = pdfh(it, \"h3&&a&&Text\");\n    let userial = pdfh(it, \".video-serial&&Text\");\n    let uimage = pdfh(it, \"img&&data-src\");\n    let u = pd(it, \"h3&&a&&href\", basicUrl);\n    bet.push({\n        title: utitle,\n        url: u,\n        pic_url: uimage,\n        desc: userial\n    });\n}\n\nreturn bet;","basicUrl":"http://www.weixine.net","findAliUrl":"return pdfa(request(input), \"body&&.module-row-text.copy\").map(v=>pdfh(v,\"a&&data-clipboard-text\"));","page":true,"lastModify":1710338033325,"group":"综合","author":""},{"name":"88网盘聚合","find":"let res = request(basicUrl+\"/api/get_zy?keyword=\" + encodeURIComponent(s));\nres = JSON.parse(res);\nreturn res.data.map(v => ({\n    title: v.title,\n    desc: v.url,\n    url: v.url\n}));","basicUrl":"http://www.662688.xyz","findAliUrl":"","page":false,"lastModify":1710338025498,"group":"综合","author":"@LoyDgIk"},{"name":"9995云盘","find":"var searchUrl = basicUrl + '/search.php?q=' + encodeURIComponent(s)+\"&page=\"+page;\nvar resp = request(searchUrl)\nvar items = pdfa(resp, \".content&&.post\");\nlet d = [];\nfor (let item of items) {\n    d.push({\n        title: pdfh(item, \"h2&&Text\"),\n        url: pd(item, \"a&&href\", basicUrl),\n        desc: \"上传时间：\"+pdfh(item, \".date&&Text\")+\"\\n简介：\"+pdfh(item, \".intro&&Text\")\n    });\n}\nreturn d;","basicUrl":"https://9995t.com","findAliUrl":"return pdfa(request(input), \".postcon&&p:has(a)&&a\").map((v)=>pdfh(v, \"a&&href\"));","page":true,"lastModify":1710338017069,"group":"综合","author":"@LoyDgIk"},{"name":"混合盘","page":true,"find":"let url = \"https://api.hunhepan.com/v1/search\";\nlet json = post(url, {\n    headers: {\n        Referer: \"https://hunhepan.com/\"\n    },\n    body: JSON.stringify({\n        \"q\": s,\n        \"page\": page,\n        \"size\": 15\n    })\n});\njson = JSON.parse(json);\nlet list = json.data.list;\nlet d = [];\nfor (let i = 0; i < list.length; i++) {\n    let it = list[i];\n    if (it.disk_type !== 'ALY' && it.disk_type !== 'QUARK' || it.share_user === \"\\u4e36***\\u4e36\") {\n        continue;\n    }\n    d.push({\n        title: it.disk_name,\n        pic_url: pd(it, \"img&&src\", url),\n        url: it.link,\n        desc: it.update_time + \"\\n\" + it.link\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"","lastModify":1710338995880,"group":"综合","author":"@LoyDgIk"},{"name":"玩偶表哥","find":"let url = basicUrl + \"/index.php/vod/search.html?wd=\"+encodeURIComponent(s)+\"&page=\"+page\nlet html = request(url);\nlet arr = parseDomForArray(html, \".module-items&&.module-search-item\");\n\nlet bet = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let utitle = pdfh(it, \"h3&&a&&Text\");\n    let userial = pdfh(it, \".video-serial&&Text\");\n    let uimage = pdfh(it, \"img&&data-src\").replace(\"/img.php?url=\",\"\");\n    let u = pd(it, \"h3&&a&&href\", basicUrl);\n    bet.push({\n        title: utitle,\n        url: u,\n        pic_url: uimage,\n        desc: userial\n    });\n}\n\nreturn bet;","basicUrl":"https://wobge.run.goorm.io","findAliUrl":"return pdfa(request(input), \"body&&.module-row-text.copy\").map(v=>pdfh(v,\"a&&data-clipboard-text\"));","page":true,"lastModify":1710338009277,"group":"综合","author":"@LoyDgIk"},{"name":"小云","page":true,"find":"let api = \"/api/validate/search?wd=\" + encodeURIComponent(s) + \"&mode=90001&stype=20100&uk=&page=\" + page + \"&limit=20&screen_filetype=undefined\";\nlet json = post(basicUrl + api, {\n    body: \"data=\" + api,\n    headers: {\n        Referer: \"https://www.yunso.net/index/user/s?wd=\" + encodeURIComponent(s)\n    }\n});\n\nlet html = JSON.parse(json).data;\nlet list = pdfa(html, \"body&&.layui-card:has(button)\");\nlet d = [];\nfor (let item of list) {\n    let title = pdfh(item, \"a&&Text\").replace(\"#\\u6587\\u4ef6\\u5939 \", \"\");\n    d.push({\n        title: title,\n        url: pdfh(item, \"a&&id\"),\n        desc: pdfh(item, \".layui-card-body&&img&&alt\")+\"·\"+(pdfh(item, \".layui-badge&&Text\")||\"永久\")\n    });\n}\nreturn d;","findAliUrl":"let url = buildUrl(basicUrl+\"/api/validate/geturl\", {\n    r: String(new java.util.Random().nextFloat()),\n    qid: input\n});\nlet json = JSON.parse(fetch(url, {\n    headers: {\n        Referer: basicUrl,\n        Cookie: \"#noCookie#\"\n    }\n}));\nif (json.code == -1) {\n    return \"toast://\" + json.msg;\n} else {\n    return json.data;\n}","lastModify":1711178860915,"basicUrl":"https://www.yunso.net","group":"综合","author":"@LoyDgIk","ruleType":"undefined"},{"name":"懒鱼看看","find":"var searchUrl = basicUrl + '/search?keywords=' + encodeURIComponent(s);\nvar resp = request(searchUrl)\nvar items = pdfa(resp, \".py-10&&a\");\nlet d = [];\nfor (let item of items) {\n    d.push({\n        title: pdfh(item,\".text-center&&Text\"),\n        url: pd(item,\"a&&href\", basicUrl),\n    });\n}\nreturn d;","basicUrl":"https://lykk.top","findAliUrl":"let html = request(input);\n\nlet arr = pdfa(html, \"ul&&a\").map(v => pdfh(v, \"a&&href\")).filter(v => v.includes(\"alipan\") || v.includes(\"quark\"));\nif (arr.length === 0) {\n    return input;\n} else {\n    return arr;\n}","page":false,"lastModify":1710338156733,"group":"综合","author":"@LoyDgIk"},{"name":"全网盘搜索","find":"//是否开启只显示阿里链接\nlet onlyAli = false;\n\nconst alitest = $.require(\"alitest\");\nlet apis = [\"getJuzi\", \"getTop\", \"getDyfx\", \"getTTZJB\", \"getGirls\", \"getXiaoy\", \"getGGang\"];\nlet fetchTasks = apis.map((api) => {\n    return {\n        url: basicUrl + \"/v/api/\" + api,\n        options: {\n            body: {\n                name: s,\n                token: \"i69\"\n            },\n            method: 'POST'\n        }\n    }\n});\nlet responses = batchFetch(fetchTasks);\n\n\nlet d = [];\n\nfor (let res of responses) {\n    try {\n        let list = JSON.parse(res).list;\n        for (let it of list) {\n            let urls = it.answer.replace(/.*?链接：/, \"\").split(\"\\n\");\n\n            for (let url of urls) {\n                let r = url.split(\" \");\n                if (onlyAli && !alitest.test(r[0])) continue;\n                d.push({\n                    title: it.question,\n                    desc: url,\n                    url: r[0],\n                    extra: {\n                        shareId: r.length === 3 ? r[2] : undefined\n                    }\n                });\n            }\n        }\n\n    } catch (e) {\n\n    }\n}\nreturn d;","basicUrl":"http://kkkkkds.cn","findAliUrl":"","page":false,"lastModify":1710338732120,"group":"综合","author":"@LoyDgIk"},{"name":"搜搜","find":"let d = [];\n\nlet url = \"https://www.so1st.com/api/v1/search/\" + s + \"/all/\" + page * 10\n\nlet html = request(url);\nlet list = JSON.parse(html).items;\nfor (let i = 0; i < list.length; i++) {\n    let it = list[i];\n    let title = it.detail;\n    let murl = it.share_url;\n    let sz = it.size;\n    //$.dateFormat格式化时间\n    let sj = $.dateFormat(new Date(it.insert_time.split(\".\")[0]+\"Z\"), \"yyyy-MM-dd HH:mm:ss\");\n    d.push({\n        title: title,\n        url: murl,\n        desc: sz + '\\t' + sj + '\\n' + murl\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"","page":true,"lastModify":1710339048094,"group":"综合","author":""},{"name":"YaPan","find":"let d = [];\nlet aliUtil = $.require(\"aliUtil\");\nlet html = fetch(\"https://yapan.io/api/search?keyword=\" + s + \"&page_num=\" + page + \"&page_size=20&client_version=1.1.0\");\n\nlet list = JSON.parse(html).data.rows;\nfor (let i = 0; i < list.length; i++) {\n    let it = list[i];\n    let title = it.file_name;\n    let murl = it.url;\n    let type = it.updated_at;\n    if (title.includes(s)) {\n        d.push({\n            title: title,\n            desc: type,\n            url: murl\n        });\n    }\n}\nreturn d;","basicUrl":"","findAliUrl":"","page":true,"lastModify":1710339075657,"group":"综合","author":""},{"name":"皮皮虾资源","find":"var searchUrl = basicUrl + '/page/'+page+'?s='+encodeURIComponent(s);\nvar resp = request(searchUrl)\nvar items = pdfa(resp, \"body&&.col-md-6\");\nlet d = [];\nfor (let item of items) {\n    d.push({\n        title: pdfh(item, \".entry-title&&Text\"),\n        pic_url: pdfh(item, \".cover&&style\").match(/https?.*?\\.jpg/)[0]+\"@Referer=\"+basicUrl,\n        url: pdfh(item, \".u-permalink&&href\"),\n        desc: \"上传时间：\"+pdfh(item, \".entry-action&&Text\")+\"\\n\"+pdfh(item, \".entry-category&&Text\"),\n    });\n}\nreturn d;","basicUrl":"https://ppxzy.net","findAliUrl":"let list = pdfa(fetch(input), \"body&&.dlipp-dl-btn\");\nlet id = input.split('net/')[1].split('.')[0];\nlet aurl = JSON.parse(post(\"https://ppxzy.net/wp-admin/admin-ajax.php\", {\n    body: {\n        action: \"wb_dlipp_front\",\n        pid: id,\n        rid: \"local\",\n    }\n})).data.url;\nlet kurl = JSON.parse(post(\"https://ppxzy.net/wp-admin/admin-ajax.php\", {\n    body: {\n        action: \"wb_dlipp_front\",\n        pid: id,\n        rid: \"xunlei\",\n    }\n})).data.url\nreturn new EasyNextPage(list.map(v => {\n    let title = pdfh(v, \"span&&Text\");\n    let url = /阿里/.test(title) ? aurl : /夸克/.test(title) ? kurl : input;\n    return {\n        aliUrl: url,\n        title: title,\n    };\n}), \"text_1\");","page":true,"lastModify":1710339014387,"group":"综合","author":""},{"name":"团长资源","find":"var searchUrl = basicUrl+\"/page/\"+page+\"?s=\"+encodeURIComponent(s)+\"&type=post\";\nvar resp = request(searchUrl)\nvar items = pdfa(resp, \"body&&.post-list-item\");\nlet d = [];\nfor (let item of items) {\n    d.push({\n        title: pdfh(item, \"h2&&Text\"),\n        pic_url: pdfh(item, \".lazy&&data-src\"),\n        url: pd(item, \"a&&href\", basicUrl),\n        //desc: \"上传时间：\"+pdfh(item, \".date&&Text\")+\"\\n简介：\"+pdfh(item, \".intro&&Text\"),\n    });\n}\nreturn d;","basicUrl":"https://t-rex.tzfile.com","findAliUrl":"let id = input.split('com/')[1].split('.')[0];\nlet html = fetch(input);\nif (html.includes('download-button-box')) {\n    let list = JSON.parse(post(\"https://t-rex.tzfile.com/wp-json/b2/v1/getDownloadData\", {\n        body: {\n            \"post_id\": id\n        }\n    }))[0].button\n    return new EasyNextPage(list.map(v => {\n        let title = v.name;\n        let link = v.link;\n        let i = link.split('i=')[1]\n        let token = JSON.parse(post(\"https://t-rex.tzfile.com/wp-json/b2/v1/getDownloadPageData\", {\n            body: {\n                \"post_id\": id,\n                \"index\": \"0\",\n                \"i\": i\n            }\n        })).button.url\n        let url = request(\"https://t-rex.tzfile.com/redirect?token=\" + token).match(/(https:\\/\\/.*)[\"]/)[1]\n        return {\n            aliUrl: url,\n            title: title,\n        };\n    }), \"text_1\");\n} else {\n    let list = pdfa(html, \".entry-content&&p:has(a)\")\n    return new EasyNextPage(list.map(v => {\n        let title = pdfh(v, \"p&&Text\");\n        let url = pdfh(v, \"a&&href\");\n        return {\n            aliUrl: url,\n            title: title,\n        };\n    }), \"text_1\");\n}","page":true,"lastModify":1710339010056,"group":"综合","author":""},{"name":"影搜","author":"Mike","find":"let api = basicUrl + \"/v3/ali/search\";\n//log(api)\nlet res = post(api, {\n    headers: {\n        \"User-Agent\": MOBILE_UA,\n        \"Referer\": 'https://yingso.fun/',\n        \"Content-Type\": 'application/json',\n        'Origin': 'https://yingso.fun',\n        'Accept': '*/*',\n        'Host': 'ys.api.yingso.fun',\n        'Accept-Language': 'zh-CN,zh;q=0.9,en-GB;q=0.8,en-US;q=0.7,en;q=0.6'\n    },\n    body: JSON.stringify({\n        \"pageNum\": 1,\n        \"pageSize\": 30,\n        \"title\": s,\n        \"root\": 0,\n        \"cat\": \"all\"\n    })\n});\n\nres = JSON.parse(res)\nreturn res.data.filter(v => v.root == 1 || v.root == 2).map(v => ({\n    title: v.title,\n    desc: v.root == 1 ? 'https://www.aliyundrive.com/s/' + v.key : 'https://pan.quark.cn/s/' + v.key,\n    url: v.root == 1 ? 'https://www.aliyundrive.com/s/' + v.key : 'https://pan.quark.cn/s/' + v.key\n}));","basicUrl":"https://ys.api.yingso.fun","findAliUrl":"","page":true,"lastModify":1714617756464,"group":"综合","ruleType":""},{"name":"玩你老哥","author":"@LoyDgIk","find":".module-items&&.module-search-item\nh3&&a&&Text\nh3&&a&&href\n.video-serial&&Text\nimg&&data-src@js=input.replace(\"/img.php?url=\",\"\");\n","basicUrl":"https://tv.yydsys.top/index.php/vod/search/page/fypage/wd/**.html","findAliUrl":"@js= pdfa(request(input), \"body&&.module-row-text.copy\").map(v=>pdfh(v,\"a&&data-clipboard-text\"));","page":true,"lastModify":1711532236208,"group":"阿里","ruleType":"HTML"},{"name":"土豆阿里资源站","author":"@LoyDgIk","find":".module-items&&.module-search-item\nh3&&Text\n.video-info-footer&&a&&href\n.video-info&&Text\nimg&&data-src","basicUrl":"https://tudou.lvdoui.top/index.php/vod/search/page/fypage/wd/**.html","findAliUrl":".btn-pc.btn-down&&href","page":true,"lastModify":1711438191054,"group":"阿里","ruleType":"HTML"},{"name":"SSGO","author":"@LoyDgIk","find":"let d = [];\nlet html = request(basicUrl + \"?query=\" + encodeURIComponent(s) + \"&page=\" + page);\nlet json = JSON.parse(pdfh(html, \"#__NUXT_DATA__&&Html\"));\nlet list = [];\njson.forEach(v => {\n    if ($.type(v) === \"object\" && v.hasOwnProperty(\"title\")) list.push(v);\n});\n\nfor (let it of list) {\n    let url = json[it.pan_url];\n    if (!url.startsWith(\"http\")) {\n        url = \"https://www.\" + url;\n    }\n    d.push({\n        title: json[it.title],\n        desc: url,\n        url: url,\n        sharePwd: String(json[it.extract_code]).replace(/提取码: ?/, \"\"),\n    });\n}\nreturn d;","basicUrl":"https://ssgo.app","findAliUrl":"","page":true,"lastModify":1711197875534,"group":"阿里","ruleType":""},{"name":"猫狸盘搜","page":true,"find":"let html = request(basicUrl + \"/search?page=\" + page + \"&k=\" + s + \"&s=0&t=-1\", {\n    headers: {\n        \"Referer\": basicUrl + \"/search?k=\" + s\n    }\n});\nlet arr = pdfa(html, \"#app&&a,2:12\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = \"<div>\" + arr[i] + \"</div>\";\n    let u = pd(it, \"a&&href\", basicUrl)\n    if (!u.includes(\"/s/\")) {\n        continue;\n    }\n    if (u.startsWith(basicUrl)) {\n        u = u.replace(\"/s/\", \"/cv/\");\n    }\n    d.push({\n        title: pdfh(it, \"template&&Text\"),\n        url: u,\n        desc: pdfh(it, \"template,1&&Text\")\n    });\n}\nreturn d;","findAliUrl":"let html = request(input, {\n    headers: {\n        \"Cookie\": \"Hm_lvt_02f69e0ba673e328ef49b5fb98dd4601=1709219732; _ga=GA1.1.1534913360.1709219732; cto_bundle=_TCD4F94QXolMkZvclFoaGdHQXdYZFhwand0bUZveXMybFVrdVdUaU5seFZqazJjaU1KanNBeU9QbDd3V1ZsdWJpNXcxRElXaXBTaDE1d2NJbTN3WnlRQlhhVkJwRUFVWWNJVGpQQ2RVSlpEclQ1JTJCUHowd1lOWWdTRGRMRnVTT2hhRkJVWlpKaDYlMkJTOXBTWXlMdE1kaFd1clF2NUElM0QlM0Q; _egg=6bf530ff327a42c69b703ea8ded8722ae; __gads=ID=c8f120358e8dcba3:T=1709219733:RT=1709221742:S=ALNI_Mb2ya0AoMu9ClBTKCIPY4dQB7ax9Q; __gpi=UID=00000d20653a2d2e:T=1709219733:RT=1709221742:S=ALNI_MbkpVndVu7n6shC-k__7ywvq8TFrQ; __eoi=ID=822eed7db2fbfddc:T=1709219733:RT=1709221742:S=AA-Afja6a0L9khyWcbPKSDb4cE7_; mysession=MTcwOTIyMTg5OXxEdi1CQkFFQ180SUFBUkFCRUFBQUpfLUNBQUVHYzNSeWFXNW5EQXdBQ25ObFlYSmphRjlyWlhrR2MzUnlhVzVuREFVQUEtYUlrUT09fMuSdhsZfmr4xiSdAFPI69rxp6n6ELGKTJ5BZAhkTohE; _ga_NYNC791BP2=GS1.1.1709219731.1.1.1709221903.0.0.0; _ga_0B2NFC7Z09=GS1.1.1709219731.1.1.1709221903.56.0.0; Hm_lpvt_02f69e0ba673e328ef49b5fb98dd4601=1709221904; _bid=976011d773571309f78cec47f6b090bf\",\n        \"Referer\": input.replace(\"/cv/\", \"/s/\")\n    },\n    redirect: false\n});\nhtml = parseDomForHtml(html, \"a&&href\");\nif (html.length > 0) {\n    return html;\n} else {\n    return input;\n}","basicUrl":"https://www.alipansou.com","lastModify":1714617767044,"group":"阿里","author":"@LoyDgIk","ruleType":""},{"name":"玩偶哥哥","find":".module-items&&.module-search-item\nh3&&a&&Text\nh3&&a&&href\n.video-serial&&Text\nimg&&data-src@js=input.replace(\"/img.php?url=\",\"\");\n","basicUrl":"http://wogg.xyz/index.php/vodsearch/**----------fypage---.html","findAliUrl":"@js= pdfa(request(input), \"body&&.module-row-text.copy\").map(v=>pdfh(v,\"a&&data-clipboard-text\"));","page":true,"lastModify":1711177671069,"group":"阿里","author":"@LoyDgIk","ruleType":"HTML"},{"name":"小纸条","page":false,"find":"let aliUtil = $.require(\"aliUtil\");\n\nfunction gettoken() {\n    if (getMyVar(\"xzytoken\", \"\").length == 0) {\n        let token = JSON.parse(post(\"https://gitcafe.net/tool/alipaper/\", {\n            headers: {\n                \"Referer\": \"https://u.gitcafe.ink/\"\n            },\n            body: {\n                action: \"get_token\"\n            }\n        })).data;\n        putMyVar(\"xzttoken\", token);\n    }\n    return getMyVar(\"xzttoken\", \"\");\n}\n\nfunction cat_code(a) {\n    var d, e, b = [\"\\u534e\\u8bed\\u7535\\u89c6\", \"\\u65e5\\u97e9\\u7535\\u89c6\", \"\\u6b27\\u7f8e\\u7535\\u89c6\", \"\\u5176\\u4ed6\\u7535\\u89c6\", \"\\u534e\\u8bed\\u7535\\u5f71\", \"\\u65e5\\u97e9\\u7535\\u5f71\", \"\\u6b27\\u7f8e\\u7535\\u5f71\", \"\\u5176\\u4ed6\\u7535\\u5f71\", \"\\u534e\\u8bed\\u52a8\\u6f2b\", \"\\u65e5\\u97e9\\u52a8\\u6f2b\", \"\\u6b27\\u7f8e\\u52a8\\u6f2b\", \"\\u7eaa\\u5f55\\u7247\", \"\\u7efc\\u827a\\u7247\", \"\\u6559\\u80b2\\u57f9\\u8bad\", \"\\u5176\\u4ed6\\u89c6\\u9891\", \"\\u534e\\u8bed\\u97f3\\u4e50\", \"\\u65e5\\u97e9\\u97f3\\u4e50\", \"\\u6b27\\u7f8e\\u97f3\\u4e50\", \"\\u5176\\u4ed6\\u97f3\\u4e50\", \"\\u5a31\\u4e50\\u8f6f\\u4ef6\", \"\\u7cfb\\u7edf\\u8f6f\\u4ef6\", \"\\u7f51\\u7edc\\u8f6f\\u4ef6\", \"\\u529e\\u516c\\u8f6f\\u4ef6\", \"\\u5176\\u4ed6\\u8f6f\\u4ef6\", \"\\u6f2b\\u753b\", \"\\u5c0f\\u8bf4\", \"\\u51fa\\u7248\\u4e66\", \"\\u77e5\\u8bc6\\u57f9\\u8bad\", \"\\u5176\\u4ed6\\u6587\\u6863\", \"\\u58c1\\u7eb8\", \"\\u4eba\\u7269\", \"\\u98ce\\u666f\", \"\\u5176\\u4ed6\\u56fe\\u7247\", \"\\u5176\\u4ed6\"],\n        c = [\"hyds\", \"rhds\", \"omds\", \"qtds\", \"hydy\", \"rhdy\", \"omdy\", \"qtdy\", \"hydm\", \"rhdm\", \"omdm\", \"jlp\", \"zyp\", \"jypx\", \"qtsp\", \"hyyy\", \"rhyy\", \"omyy\", \"qtyy\", \"kfrj\", \"xtrj\", \"wlrj\", \"bgrj\", \"qtrj\", \"mh\", \"xs\", \"cbs\", \"zspx\", \"qtwd\", \"bz\", \"rw\", \"fj\", \"qttp\", \"qt\"];\n    for (d = 0, e = c.length; e > d; d++) {\n        if (c[d] == a) {\n            return b[d];\n        }\n    }\n}\nlet d = [];\nlet html = post(\"https://gitcafe.net/tool/alipaper/\", {\n    headers: {\n        \"Referer\": \"https://u.gitcafe.ink/\"\n    },\n    body: {\n        action: \"search\",\n        from: \"web\",\n        token: gettoken(),\n        keyword: s\n    }\n});\nlet list = JSON.parse(html);\nif (list.data) {\n    list = list.data;\n}\nfor (let i = 0; i < list.length; i++) {\n    let it = list[i];\n    let title = it.title;\n    let murl = \"https://www.aliyundrive.com/s/\" + it.alikey;\n    if (!aliUtil.checkali(murl)) {\n        continue;\n    }\n    if (title.includes(s)) {\n        d.push({\n            title: \"\\u221a \" + title,\n            desc: cat_code(it.cat),\n            extra: {\n                des: it.des\n            },\n            url: murl\n        });\n    }\n}\nreturn d;","basicUrl":"","findAliUrl":"","lastModify":1706427658817,"group":"阿里"},{"name":"皮卡","find":"let html = request(buildUrl(basicUrl + \"/search/\", {\n    pan: \"aliyundrive\",\n    q: encodeURIComponent(s),\n    page: page\n}));\nlet list = pdfa(html, \"body&&.search-item:has(i)\");\nlet d = [];\nfor (let it of list) {\n    d.push({\n        title: pdfh(it, \"a&&Text\"),\n        url: pdfh(it, \"a&&href\"),\n        desc: pdfh(it, \".search-file-des&&a&&href\"),\n    });\n}\n\nreturn d;","basicUrl":"https://www.pikaso.top","findAliUrl":"","page":true,"lastModify":1710337744552,"group":"阿里","author":"@LoyDgIk"},{"name":"盘友圈","find":"let aliUtil = $.require(\"aliUtil\");\n//请不要直接用海阔的eval(getCryptoJS())，进行批量搜索的时候会重复加载导致性能浪费\nlet CryptoJS = aliUtil.getCryptoJS();\n\nfunction AESEncrypt(e) {\n    let n = CryptoJS.enc.Utf8.parse(\"Qb8uTX98yDe49fNL\"),\n        i = CryptoJS.enc.Utf8.parse(\"gZ2PEPThrWGeWME9\");\n\n    let l = CryptoJS.enc.Utf8.parse(e);\n    return CryptoJS.AES.encrypt(l, n, {\n        iv: i,\n        mode: CryptoJS.mode.CBC,\n        padding: CryptoJS.pad.Pkcs7\n    }).ciphertext.toString().toLowerCase()\n}\nlet html = request(basicUrl + \"/search/\" + AESEncrypt(\"ali|\" + s + \"|\" + page));\n//log(html);\nlet sign = html.match(/\"sign\\\\\":\\\\\"(.*?)\\\\\"/)[1];\n\nlet json = request(basicUrl + \"/api/search?sign=\" + sign);\nlet list = JSON.parse(json).data.hits;\nlet d = [];\nfor (let it of list) {\n    //内置工具，匹配文本中的阿里链接，第二个参数如果是true会匹配多个\n    let url = aliUtil.matchAliUrl(it.desc);\n    if (!url) break;\n    let title = it.desc.match(/(名称：|◎片　　名\\s*?)(.*?)\\n/);\n    d.push({\n        title: (title && title[2]) || s,\n        url: url,\n        pic_url: \"https://panyq.com/_next/image?url=https%3A%2F%2Fpanyq.dig77.com%2Ffile%2Fpanyq-images%2F\" + encodeURIComponent(it.image) + \"&w=640&q=75\",\n        desc: url\n    });\n}\n\nreturn d;","basicUrl":"https://panyq.com","findAliUrl":"","page":true,"lastModify":1710337753694,"group":"阿里","author":"@LoyDgIk"},{"name":"学霸网盘","find":"let url = basicUrl + (page>1?\"/page/\"+page:\"\")+\"?cat&s=\"+encodeURIComponent(s);\nlet html = request(url);\nlet arr = parseDomForArray(html, \".posts-warp&&.col\");\n\nlet bet = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let utitle = pdfh(it, \"h2&&Text\");\n    let userial = pdfh(it, \".pub-date&&Text\");\n    let uimage = pdfh(it, \"a&&data-bg\");\n    let u = pd(it, \"a&&href\", basicUrl);\n    bet.push({\n        title: utitle,\n        url: u,\n        pic_url: uimage,\n        desc: userial\n    });\n}\n\nreturn bet;","basicUrl":"https://www.xbwpys.com","findAliUrl":"return $.require(\"aliUtil\").matchAliUrl(pdfh(fetch(input),\"body&&.post-content&&Html\"))||input;","page":true,"lastModify":1710338714464,"group":"阿里","author":"@LoyDgIk"},{"name":"盘他一下","find":"var resp = request(buildUrl(basicUrl + \"/api/search\", {\n    server: \"ali\",\n    time: \"all\",\n    category: \"all\",\n    filter: \"exact\",\n    sort: \"desc\",\n    keyword: encodeURIComponent(s),\n    page: page\n}));\nvar items = JSON.parse(resp).data;\nlet d = [];\nlet aliUtil = $.require(\"aliUtil\");\nfor (let item of items) {\n    d.push({\n        title: item.title,\n        url: basicUrl + item.link+\"#\"+user.extra,\n        desc: \"时间:\" + $.dateFormat((Number(item.stime) || 0) * 1000, \"yyyy-MM-dd HH:mm:ss\") + \" 大小:\" + aliUtil.bytesToSize(item.size)\n    });\n}\nreturn d;","basicUrl":"https://panothers.com","findAliUrl":"input = input.split(\"#\");\nlet json = JSON.parse(request(input[0].replace(\"/resource/\", \"/api/resources/\"), {\n    headers: {\n        referer: input[0],\n        authorization: \"Bearer \" + input[1]\n    }\n}));\nreturn \"https://www.aliyundrive.com/s/\"+json.data.link;\n","page":true,"lastModify":1710337770357,"registerUrl":"https://panothers.com/login","group":"阿里","author":"@LoyDgIk"},{"name":"云盘分享社区","page":true,"find":"let home = \"https://yunpan1.cc\";\nlet d = [];\nlet html = request(buildUrl(home + \"/api/discussions\", {\n    \"include\": \"user,lastPostedUser,mostRelevantPost,mostRelevantPost.user,tags,tags.parent,firstPost\",\n    \"filter[q]\": s,\n    \"page[offset]\": 20 * (page - 1)\n}), {\n    headers: {\n        \"content-type\": \"application/json\",\n        \"Referer\": \"https://pan666.net/?q=\" + s\n    }\n});\nlet list = JSON.parse(html).data;\nfor (let i = 0; i < list.length; i++) {\n    let item = list[i].attributes;\n    let url = home + \"/d/\" + item.slug;\n    d.push({\n        title: item.title,\n        desc: \"\\u53d1\\u5e03\\u65f6\\u95f4\\uff1a\" + $.dateFormat(new Date(item.createdAt), \"yyyy-MM-dd HH:mm:ss\"),\n        url: url,\n        extra: {\n            longClick: [{\n                title: \"\\u8fdb\\u5165\\u5e16\\u5b50\",\n                js: JSON.stringify(\"hiker://page/ysfx?webUrl=\" + encodeURIComponent(url))\n            }]\n        }\n    });\n}\nreturn d;","findAliUrl":"let html = pdfh(request(input), \"Text\");\nlet _links = html.match(/https:\\/\\/(www\\.aliyundrive\\.com\\/s|alywp\\.net)\\/\\w*/g) || [];\nlet sharePwd = html.match(/提取码[:：]\\s*?(\\w{4})/);\nsharePwd = Array.isArray(sharePwd) && sharePwd.length > 0 ? sharePwd[1] : \"\";\nif (_links.length > 1 && _links[1].replace(_links[0], \"\").replace(/[a-zA-Z0-9]+/g, \"\") == \"\") {\n    return {\n        aliUrl: _links[1],\n        sharePwd: sharePwd\n    };\n} else {\n    if (_links.length > 0) {\n        return {\n            aliUrl: _links[0],\n            sharePwd: sharePwd\n        };\n    } else {\n        return \"hiker://page/ysfx?webUrl=\" + encodeURIComponent(input);\n    }\n}","basicUrl":"","lastModify":1706427715017,"group":"阿里"},{"name":"阿里小站","page":true,"find":"let home = \"https://pan666.net\";\nlet d = [];\nlet html = request(buildUrl(home + \"/api/discussions\", {\n    \"include\": \"user,lastPostedUser,mostRelevantPost,mostRelevantPost.user,tags,tags.parent,firstPost\",\n    \"filter[q]\": s,\n    \"page[offset]\": 20 * (page - 1)\n}), {\n    headers: {\n        \"content-type\": \"application/json\",\n        \"Referer\": \"http://alixiaozhan.vip/?q=\" + s\n    }\n});\nlet list = JSON.parse(html).data;\nfor (let i = 0; i < list.length; i++) {\n    let item = list[i].attributes;\n    let url = home + \"/d/\" + item.slug;\n    d.push({\n        title: item.title,\n        desc: \"\\u53d1\\u5e03\\u65f6\\u95f4\\uff1a\" + $.dateFormat(new Date(item.createdAt), \"yyyy-MM-dd HH:mm:ss\"),\n        url: url,\n        extra: {\n            longClick: [{\n                title: \"\\u8fdb\\u5165\\u5e16\\u5b50\",\n                js: JSON.stringify(\"hiker://page/ysfx?webUrl=\" + encodeURIComponent(url))\n            }]\n        }\n    });\n}\nreturn d;","findAliUrl":"let html = pdfh(request(input), \"Text\");\nlet _links = html.match(/https:\\/\\/(www\\.aliyundrive\\.com\\/s|alywp\\.net)\\/\\w*/g) || [];\nlet sharePwd = html.match(/提取码[:：]\\s*?(\\w{4})/);\nsharePwd = Array.isArray(sharePwd) && sharePwd.length > 0 ? sharePwd[1] : \"\";\nif (_links.length > 1 && _links[1].replace(_links[0], \"\").replace(/[a-zA-Z0-9]+/g, \"\") == \"\") {\n    return {\n        aliUrl: _links[1],\n        sharePwd: sharePwd\n    };\n} else {\n    if (_links.length > 0) {\n        return {\n            aliUrl: _links[0],\n            sharePwd: sharePwd\n        };\n    } else {\n        return \"hiker://page/ysfx?webUrl=\" + encodeURIComponent(input);\n    }\n}","basicUrl":"","lastModify":1714643235955,"group":"阿里","author":"","ruleType":""},{"name":"必应","page":true,"find":"let url = \"https://cn.bing.com/search?q=\" + s + \"+aliyundrive&qs=ds&form=QBRE\";\nif (page != 1) {\n    url = getMyVar(\"bing\", url);\n}\nlet html = request(url, {\n    headers: {\n        \"Referer\": \"https://cn.bing.com/\",\n        \"Accept\": \"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\"\n    }\n});\nlet arr = pdfa(html, \"body&&a\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = pd(it, \"a&&href\", url);\n    let t = pdfh(it, \"a&&Text\");\n    if (it.includes(\"Next page\") || it.includes(\"\\u4e0b\\u4e00\\u9875\")) {\n        let u2 = pd(it, \"a&&href\", url);\n        putMyVar(\"bing\", u2);\n    }\n    if (u == null || t == null || !it.includes(s)) {\n        continue;\n    }\n    if (!it.includes(\"\\u7f51\\u76d8\") && !it.includes(\"\\u4e91\\u76d8\") && !it.includes(\"aliyundrive\") && !it.includes(\"yunpan\")) {\n        continue;\n    }\n    if (u.startsWith(\"https://cn.bing.com/\")) {\n        continue;\n    }\n    let dom = getHome(u).replace(\"http://\", \"\").replace(\"https://\", \"\");\n    let _links = t.match(/https:\\/\\/(www\\.aliyundrive\\.com\\/s|alywp\\.net)\\/\\w*/g) || [];\n    let c = null;\n    if (_links.length > 1 && _links[1].replace(_links[0], \"\").replace(/[a-zA-Z0-9]+/g, \"\") == \"\") {\n        c = _links[1];\n    } else {\n        if (_links.length > 0) {\n            c = _links[0];\n        }\n    }\n    d.push({\n        title: t,\n        desc: dom,\n        url: c != null ? c : u,\n        extra: {\n            longClick: [{\n                title: \"\\u8fdb\\u5165\\u7f51\\u7ad9\",\n                js: JSON.stringify(\"hiker://page/ysfx?webUrl=\" + encodeURIComponent(u))\n            }]\n        }\n    });\n}\nreturn d;","findAliUrl":"if (input.includes(\"aliyundrive\")) {\n    return input;\n}\nlet html = request(input);\nvar _links = html.match(/https:\\/\\/(www\\.aliyundrive\\.com\\/s|alywp\\.net)\\/\\w*/g) || [];\nif (_links.length > 1 && _links[1].replace(_links[0], \"\").replace(/[a-zA-Z0-9]+/g, \"\") == \"\") {\n    return _links[1];\n} else {\n    if (_links.length > 0) {\n        return _links[0];\n    } else {\n        //内置子页面打开网页，网页打开阿里云盘会自动跳转到云简\n        return \"hiker://page/ysfx?webUrl=\" + encodeURIComponent(input);\n    }\n}","basicUrl":"","lastModify":1706427727736,"group":"阿里"},{"name":"DOVX搜","page":false,"find":"let url = \"https://api.dovx.tk/ali/search?wd=\" + s;\nlet html = request(url);\nlet arr = JSON.parse(html).list;\nlet d = [];\nlet aliUtil = $.require(\"aliUtil\");\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = it.vod_content;\n    if (!u.includes(\"aliyundrive\") || !aliUtil.checkali(u)) {\n        continue;\n    }\n    d.push({\n        title: \"\\u221a \" + it.vod_name,\n        pic_url: it.vod_pic,\n        url: u,\n        desc: \"\\n\" + u\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"","lastModify":1706427734882,"group":"阿里"},{"name":"盘搜","page":true,"find":"page = (page - 1) * 10;\nlet url = basicUrl+\"/search?keyword=\" + s + \"&offset=\" + page + \"&pan=aliyundrive\";\nlet html = request(url);\nlet arr = parseDomForArray(html, \".grid.grid-cols-1&&.items-start\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = parseDomForHtml(it, \"a&&href\");\n    let pic_url = parseDomForHtml(it, \"img&&src\");\n    d.push({\n        title: parseDomForHtml(it, \".break-all&&Text\").split(\"http\")[0],\n        pic_url: pic_url === \"/favicon.png\" ? \"https://www.pansearch.me/\" + pic_url : pic_url,\n        url: u,\n        desc: parseDomForHtml(it, \"p&&Text\") + \"\\n\" + u\n    });\n}\nreturn d;","basicUrl":"https://www.pansearch.me","findAliUrl":"","lastModify":1710337842342,"group":"阿里","author":"@LoyDgIk"},{"name":"云盘分享社","page":false,"find":"let aliUtil = $.require(\"aliUtil\");\nlet CryptoJS = aliUtil.getCryptoJS();\n\nfunction decry(str) {\n    var key = CryptoJS.enc.Utf8.parse(\"5F6B2AK33DASD123\");\n    var encrypted = CryptoJS.AES.decrypt(str, key, {\n        mode: CryptoJS.mode.ECB,\n        padding: CryptoJS.pad.Pkcs7\n    }).toString(CryptoJS.enc.Utf8);\n    return encrypted;\n}\nlet html = request(\"https://www.yunpanfenxiang.cn/api/bbs/api/getdata?key=\" + s + \"&type=video\", {\n    headers: {\n        \"Referer\": \"https://www.yunpanfenxiang.cn/\"\n    }\n});\nlet json = decry(JSON.parse(html).data);\nlet arr = JSON.parse(json);\n\nlet bet = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let url = it.pid;\n    bet.push({\n        url: \"https://www.yunpanfenxiang.cn/api/bbs/api/getarticle?id=\" + url,\n        title: it.title,\n        desc: it.createtime\n    });\n}\n\nreturn bet;","basicUrl":"","findAliUrl":"let json = JSON.parse(request(input, {\n    headers: {\n        \"Referer\": \"https://www.yunpanfenxiang.cn/\"\n    }\n})).data;\nlet list = json.download.split(\"@\");\nlet alist = new Set();\nfor (let j = 0; j < list.length; j++) {\n    alist.add(\"https://www.aliyundrive.com/s/\"+list[j]);\n}\nreturn Array.from(alist);","lastModify":1706427745547,"group":"阿里"},{"name":"阿里搜","page":true,"find":"let d = [];\nlet html = request(\"https://aliso.cc/s/\" + s + \"-\" + page + \"-0.html\", {});\nlet list = parseDomForArray(html, \".search-result&&.resource-item\");\nfor (let j = 0; j < list.length; j++) {\n    let u = list[j];\n    let tit = parseDomForHtml(u, \"h3&&Text\");\n    if (!tit.includes(s)) {\n        continue;\n    }\n    d.push({\n        title: tit,\n        url: parseDom(u, \"h3&&a&&href\", \"https://aliso.cc/\"),\n        desc: parseDomForHtml(u, \".time&&Text\")\n    });\n}\nreturn d;","findAliUrl":"eval(getCryptoJS());\n\nfunction decry(str) {\n    var key = CryptoJS.enc.Utf8.parse(\"9EB20DDFD6AFBD68\");\n    var encrypted = CryptoJS.AES.decrypt(str, key, {\n        iv: key,\n        mode: CryptoJS.mode.CBC,\n        padding: CryptoJS.pad.Pkcs7\n    }).toString(CryptoJS.enc.Utf8);\n    return encrypted;\n}\nlet html = request(input);\nlet but = parseDom(html, \".button&&href\", \"https://aliso.cc/\");\nlet got = request(but);\neval(parseDomForHtml(got, \"head&&script,1&&Html\"));\nreturn decry(base64.split(\"!\")[0]);","basicUrl":"","lastModify":1706427751315,"group":"阿里"},{"name":"阿里云盘网","page":true,"find":"let url = basicUrl+\"/search.php?q=\" + s + \"&page=\" + page;\nlet html = request(url, {});\nlet arr = pdfa(html, \".list&&li\");\nlet bet = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let utitle = pdfh(it, \"a&&title\");\n    let userial = pdfh(it, \".fa-clock-o&&Text\");\n    let uimage = pdfh(it, \"img&&src\");\n    let u = pd(it, \"a&&href\", basicUrl);\n    if (!utitle.includes(s)) {\n        continue;\n    }\n    bet.push({\n        title: utitle,\n        url: u,\n        pic_url: uimage,\n        desc: userial\n    });\n}\n\nreturn bet;","basicUrl":"https://www.alypw.cn","findAliUrl":"let alitest = $.require(\"alitest\");\nreturn pdfa(request(input), \".article_content&&a\").map(v => pdfh(v, \"a&&href\")).filter(v => alitest.test(v));","lastModify":1706427814773,"group":"阿里"},{"name":"易搜","page":true,"find":"let aliUtil = $.require(\"aliUtil\");\nlet CryptoJS = aliUtil.getCryptoJS();\n\nfunction keyen(str) {\n    var key = CryptoJS.enc.Utf8.parse(\"4OToScUFOaeVTrHE\"),\n        iv = CryptoJS.enc.Utf8.parse(\"9CLGao1vHKqm17Oz\");\n    var encrypted = CryptoJS.AES.decrypt({\n        ciphertext: CryptoJS.enc.Base64.parse(str)\n    }, key, {\n        iv: iv,\n        mode: CryptoJS.mode.CBC,\n        padding: CryptoJS.pad.Pkcs7\n    }).toString(CryptoJS.enc.Utf8);\n    return encrypted;\n}\nlet html = request(\"https://yiso.fun/api/search?name=\" + s + \"&pageNo=\" + page, {\n    headers: {\n        \"Referer\": \"https://yiso.fun/info?searchKey=\" + s,\n        \"Cookie\": getItem(\"yisoucooke\", \"\")\n    }\n});\nif (html.includes(\"\\u767b\\u5f55\\u7528\\u6237\\u65e0\\u9650\\u5236\")) {\n    var i = 0;\n    do {\n        var tyimglin = \"https://yiso.fun/api/user/login/captcha?t=\" + parseInt(new Date().getTime()) + \"\";\n        let img = convertBase64Image(tyimglin).split(\",\")[1];\n        let cod = request(\"https://api.xhofe.top/ocr/b64/text\", {\n            headers: {\n                \"Content-Type\": \"text/plain\"\n            },\n            body: img,\n            method: \"POST\"\n        });\n        var ver = JSON.parse(request(\"https://yiso.fun/api/user/login\", {\n            headers: {\n                \"content-type\": \"application/json\",\n                \"referer\": \"https://yiso.fun/login\",\n                \"Cookie\": getCookie(tyimglin)\n            },\n            body: {\n                \"userName\": user.account,\n                \"password\": user.password,\n                \"code\": cod\n            },\n            method: \"POST\"\n        }));\n        if (ver.code == 200) {\n            log(\"\\u6613\\u641c\\u767b\\u5165\\u9a8c\\u8bc1\\u6210\\u529f\");\n            setItem(\"yisoucooke\", getCookie(\"https://yiso.fun\"));\n            html = request(\"https://yiso.fun/api/search?name=\" + s + \"&pageNo=\" + page, {\n                headers: {\n                    \"Referer\": \"https://yiso.fun/info?searchKey=\" + s,\n                    \"Cookie\": getItem(\"yisoucooke\", \"\")\n                }\n            });\n            break;\n        }\n        i++;\n    } while (i < 4);\n}\nlet arr = JSON.parse(html).data.list;\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = keyen(it.url);\n    /*if (u == null || !u.includes(\"aliyun\")) {\n        continue;\n    }*/\n    d.push({\n        title: it.fileInfos[0].fileName,\n        url: u,\n        desc: (it.gmtShare || it.gmtCreate) + \"\\n\" + (u)\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"","registerUrl":"https://yiso.fun","lastModify":1706427810180,"group":"阿里"},{"name":"UP云搜","page":true,"find":"let url = \"https://api.upyunso2.com/search?keyword=\" + s + \"&page=\" + page + \"&s_type=1\";\nlet html = request(url, {\n    headers: {\n        \"Referer\": \"https://www.upyunso.com\",\n        \"Cookie\": \"code=1919\"\n    }\n});\nlet arr = JSON.parse(base64Decode(html)).result.items;\nlet d = [];\nif (!arr) {\n    return [];\n}\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = it.page_url;\n    if (!u.includes(\"aliyundrive\")) {\n        continue;\n    }\n    d.push({\n        title: it.title,\n        url: u,\n        desc: \"\\n\" + (u)\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"","lastModify":1706427822501,"group":"阿里"},{"name":"云盘资源","page":true,"find":"let url = basicUrl + \"/?PageIndex=\" + page + \"&PageSize=12&Keyword=\" + s + \"&Type=&Tag=\";\nlet html = request(url, {\n    headers: {\n        \"Referer\": basicUrl\n    }\n});\nlet arr = pdfa(html, \"main&&.card\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = (pdfh(it, \".card-link,1&&onclick\").split(\"window.open('\")[1] || \"\").split(\"')\")[0] || url;\n    d.push({\n        title: pdfh(it, \".card-title&&Text\"),\n        pic_url: pd(it, \"img&&src\", url),\n        url: u,\n        desc: pdfh(it, \".card-text,-1&&Text\") + \"\\n\" + u\n    });\n}\nreturn d;","basicUrl":"https://res.yunpan.win","findAliUrl":"","lastModify":1706427794938,"group":"阿里"},{"name":"资源帮","page":true,"find":"function search() {\n    let rtnList = [];\n    let resp = request(\"https://zyb.upyunso.com/v15/search?keyword=\" + en_aes(s) + \"&s_type=2&page=\" + page + \"&atk=&did=\" + generateRandomHexString(64), {\n        headers: {\n            \"user-agent\": \"Mozilla/5.0 (Linux; Android 10; Redmi Note 7 Build/QKQ1.190910.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/81.0.4044.138 Mobile Safari/537.36 uni-app Html5Plus/1.0 (Immersed/29.09091)\"\n        }\n    });\n    let respData = de_aes(resp);\n    let jsonData = JSON.parse(respData) || {};\n    let result = jsonData.result || {};\n    let items = result.items || [];\n    for (let i = 0; i < items.length; i++) {\n        let item = items[i];\n        let content = item.content || [];\n        if (content.length == 0 || !item.page_url) {\n            continue;\n        }\n        let url = de_aes(item.page_url) || \"\";\n        if (!url) {\n            continue;\n        }\n        rtnList.push({\n            title: (item.title.length > 30 ? item.title.slice(0, 27) + \"...\" : item.title) || \"\",\n            desc: \"\\u5206\\u4eab\\u65f6\\u95f4\\uff1a\" + item.insert_time,\n            url: url\n        });\n    }\n    return rtnList;\n}\n\nfunction generateRandomHexString(length) {\n    let result = \"\";\n    const characters = \"0123456789abcdef\";\n    const charactersLength = characters.length;\n    for (let i = 0; i < length; i++) {\n        result += characters.charAt(Math.floor(Math.random() * charactersLength));\n    }\n    return result;\n}\nlet aliUtil = $.require(\"aliUtil\");\nlet CryptoJS = aliUtil.getCryptoJS();\n\nfunction en_aes(e) {\n    let i = \"qq1920520460qqzz\";\n    let key = CryptoJS.enc.Utf8.parse(i);\n    var t = CryptoJS.enc.Utf8.parse(e),\n        r = CryptoJS.AES.encrypt(t, key, {\n            iv: key,\n            mode: CryptoJS.mode.CBC\n        });\n    return r.ciphertext.toString();\n}\n\nfunction de_aes(vv) {\n    let i = \"qq1920520460qqzz\";\n    let key = CryptoJS.enc.Utf8.parse(i);\n    let hexVal = CryptoJS.enc.Hex.parse(vv),\n        val = CryptoJS.enc.Base64.stringify(hexVal),\n        decrypted = CryptoJS.AES.decrypt(val, key, {\n            iv: key,\n            mode: CryptoJS.mode.CBC\n        });\n    return decrypted.toString(CryptoJS.enc.Utf8);\n}\nreturn search();","basicUrl":"","findAliUrl":"","lastModify":1706427827939,"group":"阿里"},{"name":"找资源","find":"function gethtml() {\n    let html = request(\"https://zhaoziyuan.pw/so?filename=\" + s + \"&page=\" + page, {\n        headers: {\n            \"Referer\": \"https://zhaoziyuan.pw/stop.html\",\n            \"origin\": \"https://zhaoziyuan.pw\",\n            \"Cookie\": getItem(\"zzycooke\", \"\"),\n            \"upgrade-insecure-requests\": \"1\",\n            \"content-type\": \"application/x-www-form-urlencoded\"\n        }\n    });\n    return html;\n};\nvar html = gethtml();\nif (!html.includes(\"search_box\")) {\n    if (!(user.account && user.password)) throw new Error(\"请登录账号\");\n    let userinfo = 'username=' + user.account + '&passwoxx=' + user.password;\n    let cook = JSON.parse(fetchCookie('https://zhaoziyuan.pw/logiu.html', {\n        headers: {\n            'User-Agent': MOBILE_UA,\n            'Content-Type': 'application/x-www-form-urlencoded',\n            'Origin': 'https://zhaoziyuan.pw',\n            'Referer': 'https://zhaoziyuan.pw/logiu.html',\n            \"upgrade-insecure-requests\": \"1\"\n        },\n        body: userinfo,\n        method: 'POST',\n        onlyHeaders: true,\n        withHeaders: true\n    })).join(';');\n    setItem(\"zzycooke\", cook);\n    //log(\"找资源登入\");\n    html = gethtml();\n}\n\nlet arr = pdfa(html, \"body&&.newsList&&li:not(:first-child)\");\n//log(arr);\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = pdfh(it, \"a&&href\");\n    if (u == null) {\n        continue;\n    }\n    u = \"https://zhaoziyuan.pw/\" + u;\n    //log(u);\n    let title = pdfh(it, \".news_text&&h3&&Text\");\n    if (!title) continue;\n    d.push({\n        title: title,\n        desc: pdfh(it, \".news_text&&p&&Text\"),\n        url: u\n    });\n}\nreturn d;","findAliUrl":"let html = request(input);\nvar _links = html.match(/https:\\/\\/(www\\.aliyundrive\\.com\\/s|alywp\\.net|www\\.alipan\\.com\\/s)\\/\\w*/g) || [];\n\nif (_links.length > 0) {\n\n    return _links[0];\n} else {\n    return input;\n}","page":true,"lastModify":1706427800179,"registerUrl":"https://zhaoziyuan.pw/login.html","basicUrl":"","group":"阿里"},{"name":"大盘搜","find":"let aliUtil = $.require(\"aliUtil\");\nlet CryptoJS = aliUtil.getCryptoJS();\n\nvar searchUrl = basicUrl + \"/api/resources/m-search\";\nvar time = Date.now();\nvar todoSign = \"/api/resources/m-searchKDNL\" + time;\nvar postBody = {\n    name: s,\n    current: page,\n    size: \"15\",\n};\n\nvar configs = {\n    headers: {\n        sign: CryptoJS.SHA256(todoSign).toString(),\n        timestamp: time.toString(),\n        \"user-agent\": MOBILE_UA,\n        origin: \"https://dapanso.com\",\n        \"x-requested-with\": \"XMLHttpRequest\",\n    },\n    timeout: 4000,\n    body: postBody,\n};\n\n\nlet json = JSON.parse(post(searchUrl, configs));\nlet d = [];\nfor (let it of json.ret.records) {\n    d.push({\n        title: it.name,\n        url: it.url,\n        desc: \"更新时间\" + it.updatedAt,\n    });\n}\n\nreturn d;","basicUrl":"https://dapanso.com","findAliUrl":"","page":true,"lastModify":1710337899722,"group":"阿里","author":"@LoyDgIk"},{"name":"帕卡搜索","find":"var searchUrl = basicUrl + '/search?type=1&keyword=' + encodeURIComponent(s) + '&searchType=0&page=' + page;\nvar resp = request(searchUrl)\nvar items = pdfa(resp, \".col-md-12&&.card-title\");\nlet d = [];\nfor (let item of items) {\n    d.push({\n        title: pdfh(item,\"a&&Text\").replace(\"阿里云盘 - \",\"\"),\n        url: basicUrl+\"/\"+pdfh(item,\"a&&href\"),\n        //desc: pdfh(item,\".align-items-center&&Text\"),\n    });\n}\nreturn d;","basicUrl":"https://www.cuppaso.com","findAliUrl":"return pdfh(request(input), \".btn.btn-green&&href\");","page":true,"lastModify":1710337905669,"group":"阿里","author":"@LoyDgIk"},{"name":"搜索盘","find":"var searchUrl =\r\n    basicUrl + \"/search?page=\" +\r\n    page + \"&category=&site=阿里云盘&size=&time=&keyword=\" +\r\n    encodeURIComponent(s);\r\n\r\nvar resp = request(searchUrl)\r\nvar items = pdfa(resp, \"body&&.post\");\r\nlet d = [];\r\nfor (let item of items) {\r\n    d.push({\r\n        title: pdfh(item, \"h2&&Text\"),\r\n        url: basicUrl + pdfh(item, \"a&&href\"),\r\n        desc: \"时间：\"+pdfh(item,\".feed_time&&Text\"),\r\n    });\r\n}\r\nreturn d;\n","basicUrl":"https://www.sousuopan.com","findAliUrl":"return pdfh(request(input.replace(\"file\",\"redirect\"),{\n    headers:{\n        referer:input\n    }\n}), \"#tip_msg&&a&&href\");","page":true,"lastModify":1710337916232,"group":"阿里","author":"@LoyDgIk"},{"name":"阿里神器","find":"let json = request(buildUrl(basicUrl + \"/api/search\", {\n    query: encodeURIComponent(s),\n    pageNo: page,\n    pageSize: 10\n}));\nlet list = JSON.parse(json).data;\nlet d = [];\nfor (let it of list) {\n    d.push({\n        title: it.title,\n        url: \"https://www.\" + it.pan_url,\n    });\n}\n\nreturn d;","basicUrl":"https://pan.justin3go.com","findAliUrl":"","page":true,"lastModify":1710337911365,"group":"阿里","author":"@LoyDgIk"},{"name":"无为","find":"let url = \"https://wuweipansou.top/assert/search?pageNo=\"+page+\"&keyword=\"+s+\"&ca=0&or=0&dt=1\"\nlet html = request(url);\nlet arr = parseDomForArray(html, \" .resource_list&&a\");\n\nlet bet = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let utitle = parseDomForHtml(it, \"strong&&Text\");\n    let userial = parseDomForHtml(it, \".card-bottom&&Text\");\n    let u = parseDom(it, \"a&&href\", \"https://wuweipansou.top\");\n    let ut = u.replace(\"/assert/detail/\",\"/vr/\")\n    bet.push({\n        title: utitle,\n        url: ut,\n        desc: userial\n    });\n}\n\nreturn bet;\n\n\n","basicUrl":"","findAliUrl":"return $.require(\"aliUtil\").matchAliUrl(request(input));","page":true,"lastModify":1706427770752,"group":"阿里"},{"name":"DVD","find":"var searchUrl = basicUrl + '/page/' + page + '/?s=' + encodeURIComponent(s);\nvar resp = request(searchUrl);\nvar mes = pdfh(resp, '.wp-die-message&&Text');\nif (mes != '') {\n    return [{\n        title: mes,\n        url: $('').lazyRule(() => {\n            refreshPage();\n            return 'hiker://empty'\n        })\n    }]\n}\nvar items = pdfa(resp, \".content-list&&.post\");\nlet d = [];\nfor (let item of items) {\n    d.push({\n        title: pdfh(item, \".entry-title&&Text\").replace(\"阿里云盘 - \", \"\"),\n        url: pdfh(item, \"a&&href\"),\n        desc: pdfh(item, \".entry-summary&&Text\"),\n        pic_url: pdfh(item, \"img&&data-src\"),\n    });\n}\nreturn d;","basicUrl":"http://www.dydhhy.com","findAliUrl":"return pdfa(request(input), \"body&&p:has(a[href~=/.*?ali(yun|pan).*?com/])||li:has(a[href~=/.*?ali(yun|pan).*?com/])\").map(v => pdfh(v, \"a&&href\"));","page":true,"lastModify":1706427767013,"group":"阿里"},{"name":"奇妙搜索","find":"let url;\nif (page === 1) {\n    url = buildUrl(\"https://www.magicalsearch.top/api/pshou/getData\", {\n        word: s,\n        type: \"阿里网盘\"\n    });\n} else {\n    url = buildUrl(\"https://www.magicalsearch.top/api/pshou/getNextPage\", {\n        url: \"https://api.upyunso2.com/search?s_type=2@page=\" + page + \"@keyword=\" + encodeURIComponent(s),\n        website: \"阿里网盘\"\n    });\n}\nlet result = request(url, {\n    headers: {\n        Referer: buildUrl(\"https://www.magicalsearch.top/search\", {\n            word: s,\n            cpage: 0\n        })\n    }\n});\nresult = JSON.parse(JSON.parse(result));\nlet list = result.result.items;\nlet d = [];\nfor (let it of list) {\n    if (it.id == -1) {\n        continue;\n    }\n    d.push({\n        title: it.title,\n        desc: \"日期：\" + it.insert_time + \"\\n路径：\" + it.path,\n        url: it.page_url\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"","page":true,"lastModify":1706427758826,"group":"阿里"},{"name":"奈斯搜索","author":"","find":"function gethtml() {\n    let html = request(\"https://www.niceso.net/search/?type=all&q=\" + s + \"&page=\" + page, {\n        headers: {\n            \"Cookie\": \"Hm_lvt_9c601a46769805bbd4e14236d50b0483=1712518828;Hm_lvt_b76fd56943da37dc223eb2829d4bb667=1712518855;csrftoken=LujGUqKDJD4x7jzcVNDeh294IEYsSox3GPzqlHO3Mt15mtGNZfNqfle4hEizuUgz;NiceID=t3hcu8c46ndwnmy284c13kbs8cu0hv3y;Hm_lpvt_b76fd56943da37dc223eb2829d4bb667=1712518981;Hm_lpvt_9c601a46769805bbd4e14236d50b0483=1712518988\"\n            \n        }\n    });\n    return html;\n};\nvar html = gethtml();\n\nlet list = pdfa(html, \"body&&.search-item\");\nlet d = [];\nfor (let it of list) {\n    d.push({\n        title: pdfh(it, \"a&&Text\"),\n        url: basicUrl+pdfh(it, \"a&&href\"),\n        desc: pdfh(it, \".search-file-size&&Text\")+\" \"+pdfh(it, \".search-file-num&&Text\"),\n    });\n}\nreturn d;","basicUrl":"https://www.niceso.net","findAliUrl":"let html = request(input, {\n    headers: {\n        \"Cookie\": \"Hm_lvt_9c601a46769805bbd4e14236d50b0483=1712518828;Hm_lvt_b76fd56943da37dc223eb2829d4bb667=1712518855;csrftoken=LujGUqKDJD4x7jzcVNDeh294IEYsSox3GPzqlHO3Mt15mtGNZfNqfle4hEizuUgz;NiceID=t3hcu8c46ndwnmy284c13kbs8cu0hv3y;Hm_lpvt_b76fd56943da37dc223eb2829d4bb667=1712518981;Hm_lpvt_9c601a46769805bbd4e14236d50b0483=1712518988\"\n    }\n});\nlet url = pdfh(html, \".item-detail-visit&&data-url\");\n\nreturn \"https://www.aliyundrive.com/s/\" + base64Decode(url).split(\"/s/\")[1];","page":true,"lastModify":1713094079050,"group":"阿里","ruleType":""},{"name":"夸克搜","author":"@LoyDgIk","find":"#wrap&&a:has(div)\n.ml-2&&Text\na&&href\nspan&&Text","basicUrl":"https://www.quark.so/s?query=**&p=fypage","findAliUrl":"#__NUXT_DATA__&&Html@js=input.match(/\"(https?\\:\\/\\/pan.quark.cn.*?)\"/)[1];","page":true,"lastModify":1715691730311,"group":"夸克","ruleType":"HTML"},{"name":"夸克吧","author":"zhao","find":"body&&.excerpt:not(:matches(尊享服务))\nh2&&Text\na&&href\n\nimg&&data-src@js=input.replace(\"/wp-content/\",\"https://www.kuakeba.com/wp-content/\");\n","basicUrl":"https://www.kuakeba.com/page/fypage?s=**","findAliUrl":"@js= pdfa(request(input), '.article-content&&a[href*=\"pan.quark.cn\"]').map(v=>pdfh(v,\"a&&href\"));","page":true,"lastModify":1714617715655,"group":"夸克","ruleType":"HTML"},{"name":"短剧库","author":"@LoyDgIk","find":".sou-con-list&&li\na,-1&&title\na,-1&&href","basicUrl":"https://duanjuku.top/search.php?q=**&page=fypage","findAliUrl":".umCopyright&&a,-1&&href","page":true,"lastModify":1714405863920,"group":"夸克","ruleType":"HTML"},{"name":"短剧猫","author":"zhao","find":"let searchUrl = basicUrl + \"/api/movies?page=\" + page + \"&limit=100&name=\" + encodeURIComponent(s);\nlet response = request(searchUrl);\nlet responseData = JSON.parse(response).data;\nlet rows = responseData.rows; // 获取电影信息数组\nlet d = [];\n\nfor (let j of rows) {\n    d.push({\n        title: j.name, // 电影链接\n        url:  j.link// 电影名称\n    });\n}\n\nreturn d;","basicUrl":"https://api.djcat.sbs","findAliUrl":"","page":true,"lastModify":1713625488945,"group":"夸克","ruleType":""},{"name":"云星短剧搜索","author":"@LoyDgIk","find":"let d = [];\n\nlet html = fetchPC(basicUrl + '/api/files/vagueQuery', {\n    body: JSON.stringify({\n        name: s\n    }),\n    method: 'POST'\n});\nlet list = JSON.parse(html).data;\nlist.forEach((list) => {\n    d.push({\n        title: list.source.name.replace(/（.*/, ''),\n        desc: list.source.name.replace(/^.*?（/, '').replace(/）.*/, ''),\n        url: list.source.url\n    });\n});\nreturn d;","basicUrl":"http://dj.itvbox.cc","findAliUrl":"","page":true,"lastModify":1712561878150,"group":"夸克","ruleType":""},{"name":"星剧社","author":"季风","find":"var searchUrl = basicUrl+\"/search/?keyword=\"+encodeURIComponent(s)+\"&page=\"+page;\nvar resp = request(searchUrl)\nvar items = pdfa(resp, \"body&&.item:has(a[href^=/])\");\nlet d = [];\nfor (let item of items) {\n    d.push({\n        title: pdfh(item, \"a&&Text\"),\n        url: pd(item, \"a&&href\", basicUrl),\n        desc: pdfh(item, \".erx-num-font&&Text\"),\n    });\n}\nreturn d;","basicUrl":"https://www.star2.cn","findAliUrl":"return pdfh(fetch(input),\".dlipp-cont-bd&&a&&href\")","page":true,"lastModify":1712557420853,"group":"夸克","ruleType":""},{"name":"FRE123","author":"@LoyDgIk","find":"let d = [];\nlet html = request(basicUrl + \"/sp?query=\" + encodeURIComponent(s));\nlet json = JSON.parse(pdfh(html, \"#__NUXT_DATA__&&Html\"));\nlet list = [];\njson.forEach(v => {\n    if ($.type(v) === \"object\" && v.hasOwnProperty(\"title\")) list.push(v);\n});\nfor (let it of list) {\n    let url = json[it.url];\n    if (!url.startsWith(\"http\")) {\n        url = \"https://www.\" + url;\n    }\n    d.push({\n        title: json[it.title],\n        desc: url,\n        url: url\n    });\n}\nreturn d;","basicUrl":"https://www.fre123.com","findAliUrl":"","page":false,"lastModify":1711909602360,"group":"夸克","ruleType":""},{"name":"短剧搜","author":"@LoyDgIk","find":"let body = {\n    \"page\": page,\n    \"q\": s,\n    \"user\": \"\",\n    \"format\": [],\n    \"share_time\": \"\",\n    \"size\": 15,\n    \"type\": \"QUARK\"\n}\nlet d = [];\nlet list = JSON.parse(fetch(basicUrl+'/v1/search/disk', {\n    method: 'POST',\n    body\n})).data.list;\nfor (let _ of list) {\n    d.push({\n        title: _.disk_name,\n        desc: \"⏱️ \" + _.shared_time + \"　🔖 \" + _.share_user,\n        url: _.link\n    });\n}\nreturn d;","basicUrl":"https://duanjuso.com","findAliUrl":"","page":true,"lastModify":1711264849737,"group":"夸克","ruleType":""},{"name":"爱看短剧","author":"@LoyDgIk","find":"data\nname\nurl\n@js= $$.episodes + \"集 ⏱️\" + $$.addtime","basicUrl":"https://ys.110t.cn/api/ajax.php?act=search&name=**","findAliUrl":"","page":false,"lastModify":1711175485990,"group":"夸克","ruleType":"JSON"},{"name":"短剧S","author":"@LoyDgIk","find":"\nname\nconnection_url","basicUrl":"https://api.ssl.gs/api.php?keyword=**","findAliUrl":"","page":true,"lastModify":1711179220018,"group":"夸克","ruleType":"JSON"},{"name":"云星短剧","author":"@LoyDgIk","find":"let d = [];\nlet list = pdfa(fetch(basicUrl+\"?search=\"+encodeURIComponent(s)), \"body&&.container&&.card:has(.card-header)\");\nfor (let div of list) {\n    let href = pd(div, \"a,0&&href\", basicUrl).split(\"\\n\")[0];\n    d.push({\n        title: pdfh(div, \"strong&&Text\"),\n        url: href\n    });\n}\nreturn d;","basicUrl":"http://dj.moil.cc","findAliUrl":"","page":false,"lastModify":1711078268438,"group":"夸克"},{"name":"夸克盘搜","find":"let url = 'https://qkpanso.com/search?page='+ page +'&q=' + s + '&share_time=week&type=QUARK&user=';\nlet json = post('https://qkpanso.com/v1/search/disk', {\n    headers: {\n        Referer: url\n    },\n    body: JSON.stringify({\n        \"page\":page,\n        \"q\":s,\n        \"user\":\"\",\n        \"format\":[\".mp4\",\".mkv\",\".flv\",\".rmvb\",\".wmv\",\".3gp\",\".mov\",\".m4v\",\".swf\",\".f4v\",\".webm\",\".ogg\",\".ogv\",\".m3u8\",\".mpd\",\".avi\",\".mpg\",\".mpeg\",\".mpe\",\".mpv\",\".m2v\",\".mxf\",\".3g2\",\".f4p\",\".f4a\",\".f4b\"],\n        \"share_time\":\"week\",\n        \"size\":15,\n        \"type\":\"QUARK\"\n    })\n});\n//log(JSON)\njson = JSON.parse(json);\nlet list = json.data.list;\nlog(list)\nlet d = [];\nfor (let i = 0; i < list.length; i++) {\n    let it = list[i];\n    d.push({\n        title: it.disk_name,\n        //pic_url: pd(it, \"img&&src\", url),\n        url: it.link,\n        desc: it.shared_time + \"\\n\" + it.link\n    });\n}\nreturn d;","basicUrl":"","findAliUrl":"","page":true,"lastModify":1706595836516,"group":"夸克"},{"name":"盘搜KK","find":"page = (page - 1) * 10;\nlet url = basicUrl+\"/search?keyword=\" + s + \"&offset=\" + page + \"&pan=quark\";\nlet html = request(url);\nlet arr = parseDomForArray(html, \".grid.grid-cols-1&&.items-start\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    let it = arr[i];\n    let u = parseDomForHtml(it, \"a&&href\");\n    let pic_url = parseDomForHtml(it, \"img&&src\");\n    d.push({\n        title: parseDomForHtml(it, \".break-all&&Text\").split(\"http\")[0],\n        pic_url: pic_url === \"/favicon.png\" ? \"https://www.pansearch.me/\" + pic_url : pic_url,\n        url: u,\n        desc: parseDomForHtml(it, \"p&&Text\") + \"\\n\" + u\n    });\n}\nreturn d;","basicUrl":"https://www.pansearch.me","findAliUrl":"","page":true,"lastModify":1710337964302,"group":"夸克","author":"@LoyDgIk"},{"name":"趣盘搜","find":"var d = [];\nvar body = JSON.stringify({\n    \"style\": \"get\",\n    \"datasrc\": \"search\",\n    \"query\": {\n        \"id\": \"\",\n        \"datetime\": \"\",\n        \"commonid\": 1,\n        \"parmid\": \"\",\n        \"fileid\": \"\",\n        \"reportid\": \"\",\n        \"validid\": \"\",\n        \"searchtext\": s\n    },\n    \"page\": {\n        \"pageSize\": 10,\n        \"pageIndex\": page\n    },\n    \"order\": {\n        \"prop\": \"id\",\n        \"order\": \"desc\"\n    },\n    \"message\": \"\\u8bf7\\u6c42\\u8d44\\u6e90\\u5217\\u8868\\u6570\\u636e\"\n});\nJSON.parse(post(\"https://v.funletu.com/search\", {\n    body: body\n})).data.forEach(item => {\n    d.push({\n        title: item.title,\n        desc: \"\\u201c\\u201c\\u201d\\u201d<font color=#f13b66a>\\u8da3\\u76d8\\u641c</font>&nbsp;\" + item.category + \" \" + item.filetype + \" \" + item.updatetime,\n        url: item.url,\n        col_type: \"text_1\"\n    });\n});\nreturn d;","basicUrl":"","findAliUrl":"","page":true,"lastModify":1706599412939,"group":"夸克"},{"name":"影视搜索","author":"@LoyDgIk","find":"let url = basicUrl + \"/search.php?q=\"+encodeURIComponent(s)+\"&page=\"+page;\nlet html = request(url);\nlet arr = parseDomForArray(html, \".list&&li:has(a)\");\n\nlet bet = [];\nfor (let i = 0; i < arr.length-1; i+=2) {\n    let it = arr[i];\n    let utitle = pdfh(it, \"a,-1&&Text\");\n    let userial = pdfh(it, \"span&&Text\");\n    let itt=arr[i+1]\n    let u = pdfh(itt, \"a&&href\");\n    userial+=\"·\"+pdfh(itt, \"a&&Text\").replace(\"链接：\",\"\").replace(\"（点我跳转）\",\"\");\n    bet.push({\n        title: utitle,\n        url: u,\n        desc: userial\n    });\n}\n\nreturn bet;\n","basicUrl":"http://cssq1.kxsou.net","findAliUrl":"","page":true,"lastModify":1710488409304,"group":"夸克"},{"name":"迅雷电影天堂","find":"let url = basicUrl + \"/s/\" + s + \".html\";\r\nlet html = request(url);\r\nlet arr = parseDomForArray(html, \"body&&.b007\");\r\nlet bet = [];\r\nfor (let i in arr) {\r\n    let it = arr[i];\r\n    let utitle = pdfh(it, \"h2&&a&&Text\");\r\n    let userial = pdfh(it, \"p&&Text\");\r\n    let uimage = pdfh(it, \"img&&src\");\r\n    let u = pd(it, \"a&&href\", basicUrl);\r\n    bet.push({\r\n        title: utitle,\r\n        url: u,\r\n        pic_url: uimage,\r\n        desc: userial\r\n    });\r\n}\r\nreturn bet;","basicUrl":"https://xunlei8.cc","findAliUrl":"return new EasyNextPage(pdfa(request(input), \"body&&.baf6e960dd\").map(v => {\n    return {\n        aliUrl: pdfh(v, \"a&&href\"),\n        title: pdfh(v, \"a&&title\"),\n    };\n}), \"text_1\");","page":true,"lastModify":1706593551776,"group":"磁力"},{"name":"Mikan","find":"let key = s;\nlet html = request(basicUrl+\"/Home/Search?searchstr=\" + key);\nlet list = pdfa(html, \".m-search-content&&.m-search-item\");\nlet d = [];\nfor (let item of list) {\n    let url= pdfh(item, \"a&&href\");\n    d.push({\n        title: pdfh(item, \".text&&Text\"),\n        url: url,\n        col_type: \"text_1\",\n        desc: pdfh(item, \".date&&Text\")\n    });\n}\nreturn d;\n","basicUrl":"https://mikanime.tv","findAliUrl":"","page":true,"lastModify":1710337942253,"group":"磁力","author":"@LoyDgIk"},{"name":"磁力猫","find":"let api = \"/search-\" + encodeURIComponent(s) + \"-0-0-\" + page + \".html\";\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"body&&.ssbox\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: \"<small>\" + pdfh(arr[i], \".title&&Text\") + \"</small>\",\n        desc: pdfh(arr[i], \".sbar&&Text\").match(/(添加时间.*?)最近/)[1],\n        url: pdfh(arr[i], \".sbar&&a&&href\")\n    });\n}\nreturn d;","basicUrl":"https://clm436.buzz","findAliUrl":"","page":true,"lastModify":1706427923991,"group":"磁力"},{"name":"种子吧","find":"let api = \"/search?wd=\" + encodeURIComponent(s) + \"&sort=rel&page=\" + page;\nlet htl = pdfh(request(basicUrl + api), \"script&&Html\").replace(/document.write\\((.*?)\\)\\;/, \"$1\").replace(\"window\", \"window0\");\nlet html = eval(htl);\nlet arr = pdfa(html, \".media-list&&.media-body\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\"),\n        desc: pdfh(arr[i], \".search-info&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","basicUrl":"http://zzb00.club","findAliUrl":"let htl = pdfh(request(input), \"script&&Html\").replace(/document.write\\((.*?)\\)\\;/, \"$1\").replace(\"window\", \"window0\");\nlet html = pdfh(eval(htl), \".bt-opt&&a&&href\");\nreturn html;","page":true,"lastModify":1706427634874,"group":"磁力","magnetUrl":"let htl = pdfh(request(input), \"script&&Html\").replace(/document.write\\((.*?)\\)\\;/, \"$1\").replace(\"window\", \"window0\");\nlet html = pdfh(eval(htl), \".bt-opt&&a&&href\");\nreturn html;"},{"name":"BTSOW","page":true,"find":"let api = \"/search/\" + encodeURIComponent(s) + \"/page/\" + page;\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \".data-list&&.row:not(.hidden-xs)\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    var urll = pdfh(arr[i], \"a&&href\");\n    d.push({\n        title: pdfh(arr[i], \"a&&title\").small(),\n        desc: pdfh(arr[i], \".size-date&&Text\"),\n        url: urll.startsWith(\"http\") ? urll : \"https:\" + urll\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input, {}), \"#magnetOpen&&a&&href\");\nreturn html;","basicUrl":"https://btsow.motorcycles","findAliUrl":"var html = pdfh(request(input, {}), \"#magnetOpen&&a&&href\");\nreturn html;","lastModify":1710426491589,"group":"磁力","author":""},{"name":"BT吃力","page":true,"find":"let api = \"/search/\" + encodeURIComponent(s) + \"/page-\" + page + \".html\";\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \".list-view&&.item:not(:matches(\\u5728\\u7ebf\\u64ad\\u653e))\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"h4--.label&&Text\").small(),\n        desc: pdfh(arr[i], \"p&&Text\").match(/(文件大小.*?)文件数量/)[1].slice(0, -9),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input), \".list-unstyled&&a&&href\");\nreturn html;","basicUrl":"https://223.sokk23.buzz","findAliUrl":"var html = pdfh(request(input), \".list-unstyled&&a&&href\");\nreturn html;","lastModify":1710426571955,"group":"磁力","author":""},{"name":"磁搜.com","page":true,"find":"let api = \"/search.php?key=\" + encodeURIComponent(s) + \"&p=\" + page;\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"body&&.ssbox\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \".sbar&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input, {}), \"span&&href\");\nreturn html;","basicUrl":"https://\\u78c1\\u641c.com","findAliUrl":"var html = pdfh(request(input, {}), \"span&&href\");\nreturn html;","lastModify":1710426843864,"group":"磁力","author":""},{"name":"磁力搜索","page":false,"find":"\nlet api = \"/search?q=\" + encodeURIComponent(s);\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \".list&&.item\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \".filename&&Text\").small(),\n        desc: pdfh(arr[i], \".size&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input, {}), \"body&&.magnet-box&&input&&value\");\nreturn html;","basicUrl":"https://cilisousuo.com","findAliUrl":"var html = pdfh(request(input, {}), \"body&&.magnet-box&&input&&value\");\nreturn html;","lastModify":1710426460974,"group":"磁力","author":""},{"name":"口袋磁力","page":true,"find":"let api = \"/search/\" + encodeURIComponent(s) + \"/\" + page;\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"tbody&&tr\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \"Text\").match(/\\d+\\-\\d+\\-\\d+.*/)[0],\n        url: pdfh(arr[i], \"a,1&&href\")\n    });\n}\nreturn d;","basicUrl":"https://kd.clkd.xyz","findAliUrl":"","lastModify":1710426586216,"group":"磁力","author":""},{"name":"滴滴磁力","page":true,"find":"let api = \"/search/\" + encodeURIComponent(s) + \"_click_\" + page + \".html\";\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"body&&.panel\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \"tbody&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input), \".downbutton&&a&&href\");\nreturn html;","basicUrl":"https://g7080apmgwo1s5kn.xyz","findAliUrl":"var html = pdfh(request(input), \".downbutton&&a&&href\");\nreturn html;","lastModify":1710426620392,"group":"磁力","author":""},{"name":"舅舅磁力","page":true,"find":"let api = \"/search?sort=rele&word=\" + encodeURIComponent(s) + \"&page=\" + page;\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"body&&.list-group-item\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \".align-self-center&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input), \".bt-box&&a&&href\");\nreturn html;","basicUrl":"http://jj3488.top","findAliUrl":"var html = pdfh(request(input), \".bt-box&&a&&href\");\nreturn html;","lastModify":1710426662828,"group":"磁力","author":""},{"name":"搜番","page":true,"find":"let api = \"/s?word=\" + encodeURIComponent(s) + \"&page=\" + page;\nlet html = request(basicUrl + api, {\n    headers: {\n        Referer: \"https://cdn.sofan.one/\"\n    }\n});\nlet arr = pdfa(html, \"body&&.list-unstyled\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \".result-resource-meta-info--.common-link&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input, {\n    headers: {\n        Referer: \"https://cdn.sofan.one/\"\n    }\n}), \"#magnet-link&&a&&href\");\nreturn html;","basicUrl":"https://cdn.sofan.one:65533","findAliUrl":"var html = pdfh(request(input, {\n    headers: {\n        Referer: \"https://cdn.sofan.one/\"\n    }\n}), \"#magnet-link&&a&&href\");\nreturn html;","lastModify":1710426633855,"group":"磁力","author":""},{"name":"磁力搜","page":true,"find":"let api = \"/search-\" + encodeURIComponent(s) + \"-0-0-\" + page + \".html\";\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"body&&.ssbox\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \".title&&Text\").small(),\n        desc: pdfh(arr[i], \".sbar&&Text\").match(/(添加时间.*?)最近/)[1],\n        url: pdfh(arr[i], \".sbar&&a&&href\")\n    });\n}\nreturn d;","basicUrl":"https://cls071.buzz","findAliUrl":"","lastModify":1710426914145,"group":"磁力","author":""},{"name":"磁力片","page":true,"find":"let api = \"/so.php?page=\" + page + \"&word=\" + encodeURIComponent(s);\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"tbody&&.default:has(a[href^=/])\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \"Text\").match(/\\d+(?:\\.\\d+)?(?:\\s+)?[gmkb]+.*?(?:\\-\\d+\\s)/i)[0],\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input, {}), \"#magnet&&title\");\nreturn html;","basicUrl":"https://m.btapp.cc","findAliUrl":"var html = pdfh(request(input, {}), \"#magnet&&title\");\nreturn html;","lastModify":1710426889850,"group":"磁力","author":""},{"name":"磁力多","page":true,"find":"let api = \"/search-\" + encodeURIComponent(s) + \"-rel-\" + page + \".html\";\nlet html = request(basicUrl + api, {\n    headers: {\n        Referer: \"https://doc.htmcdn.com\"\n    }\n});\nlet arr = pdfa(html, \"body&&.ssbox:has(a)\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"h3&&Text\").small(),\n        desc: pdfh(arr[i], \"Text\").match(/添加时间.*/)[0].split(\"\\u6587\\u4ef6\\u6570\")[0],\n        url: pdfh(arr[i], \"a:matches(\\u78c1\\u529b\\u94fe\\u63a5)&&href\")\n    });\n}\nreturn d;","basicUrl":"https://doc.htmcdn.com","findAliUrl":"","lastModify":1710426794654,"group":"磁力","author":""},{"name":"磁力海","page":true,"find":"let api = \"/search-\" + encodeURIComponent(s) + \"-0-0-\" + page + \".html\";\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \".search_list&&dl\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \".info&&Text\").match(/(收录时间.*?)磁力/)[1],\n        url: pdfh(arr[i], \".info&&a&&href\")\n    });\n}\nreturn d;","basicUrl":"https://5ew3drc7.top","findAliUrl":"","lastModify":1710426778320,"group":"磁力","author":""},{"name":"磁力酷","page":true,"find":"let url = basicUrl+\"/toSearch\";\nlet json = post(url, {\n    headers: {\n        origin: basicUrl,\n        Referer: basicUrl\n    },\n    body: {\n        \"keyword\": s,\n        \"page\": page - 1,\n        \"size\": 15\n    }\n});\njson = JSON.parse(json);\nlet list = json.data.content;\nlet d = [];\n\nfunction formatFileSize(size) {\n    if (size === 0) {\n        return \"0 Bytes\";\n    }\n    var units = [\"Bytes\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    var i = Math.floor(Math.log(size) / Math.log(1024));\n    return `${(size / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;\n}\nfor (let it of list) {\n    var date = new Date(it.timestamp);\n    var year = date.getFullYear();\n    var month = date.getMonth() + 1;\n    var day = date.getDate();\n    var formattedDate = `${year}-${month < 10 ? \"0\" + month : month}-${day < 10 ? \"0\" + day : day}`;\n    d.push({\n        title: it.name.small(),\n        url: \"magnet:?xt=urn:btih:\" + it.btih,\n        desc: \"\\u6587\\u4ef6\\u5927\\u5c0f\\uff1a\" + formatFileSize(it.size) + \"\\t\\t\\u6536\\u5f55\\u65f6\\u95f4\\uff1a\" + formattedDate\n    });\n}\nreturn d;","basicUrl":"https://ciliku.net","findAliUrl":"","lastModify":1710426960639,"group":"磁力","author":""},{"name":"磁力狐","page":true,"find":"let api = \"/search?word=\" + encodeURIComponent(s) + \"&page=\" + page;\nlet html = request(basicUrl + api, {\n    headers: {\n        Referer: \"https://cache.foxs.top\"\n    }\n});\nlet arr = pdfa(html, \"body&&.search-box\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \".layui-show&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input, {\n    headers: {\n        Referer: \"https://cache.foxs.top\"\n    }\n}), \"#link-url&&a&&href\");\nreturn html;","basicUrl":"https://cache.foxs.top","findAliUrl":"var html = pdfh(request(input, {\n    headers: {\n        Referer: \"https://cache.foxs.top\"\n    }\n}), \"#link-url&&a&&href\");\nreturn html;","lastModify":1710426808259,"group":"磁力","author":""},{"name":"磁力狗猫","page":true,"find":"let api = \"/search-\" + encodeURIComponent(s) + \"-0-0-\" + page + \".html\";\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"body&&.ssbox\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \".title&&Text\").small(),\n        desc: pdfh(arr[i], \".sbar&&Text\").match(/(添加时间.*?)最近/)[1],\n        url: pdfh(arr[i], \".sbar&&a&&href\")\n    });\n}\nreturn d;","basicUrl":"https://clg162.buzz","findAliUrl":"","lastModify":1710426683142,"group":"磁力","author":""},{"name":"磁力猫狗","page":true,"find":"var word111 = s;\nvar encodebefore = base64Encode(word111);\nencodebefore = \"VjdwwW29\" + encodebefore + \"NjdwwW24\";\nvar encodebefore1111 = encodebefore.replace(/\\+/g, \"jGYXWgx13\");\nmd5pwd = encodebefore1111;\nlet api = \"/cllj.php?name=\" + md5pwd + \"&sort=&page=\" + page;\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"#Search_list_wrapper&&li:has(.Search_list_info)\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \".Search_list_info&&Text\").match(/(大小.*?)热度/)[1],\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input), \"#Information_copy_text&&value\");\nreturn html;","basicUrl":"https://clm1.clmapp1.xyz","findAliUrl":"var html = pdfh(request(input), \"#Information_copy_text&&value\");\nreturn html;","lastModify":1710426708371,"group":"磁力","author":""},{"name":"磁力蜘蛛","page":true,"find":"let api = \"/so/\" + encodeURIComponent(s) + \"_rel_\" + page + \".html\";\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"body&&.search-item\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&Text\").small(),\n        desc: pdfh(arr[i], \".item-bar&&Text\"),\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input), \"#m_link&&value\");\nreturn html;","basicUrl":"http://www.btmovi.click","findAliUrl":"var html = pdfh(request(input), \"#m_link&&value\");\nreturn html;","lastModify":1710426983283,"group":"磁力","author":""},{"name":"无极磁链","page":false,"find":"let api = \"/search?q=\" + encodeURIComponent(s);\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"table&&tr\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"p&&Text\").small(),\n        desc: pdfh(arr[i], \"Text\").match(/\\d+(\\.?\\d+)?[gmkb]+/i)[0],\n        url: basicUrl + pdfh(arr[i], \"a&&href\")\n    });\n}\nreturn d;","magnetUrl":"var html = pdfh(request(input), \".magnet-box&&input&&value\");\nreturn html;","basicUrl":"https://0cili.top","findAliUrl":"var html = pdfh(request(input), \".magnet-box&&input&&value\");\nreturn html;","lastModify":1710426822993,"group":"磁力","author":""},{"name":"U3C3","page":true,"find":"let api = \"/?p=\" + page + \"&search2=eelja3lfea&search=\" + encodeURIComponent(s);\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"tbody&&.default\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a,1&&title\").small(),\n        desc: pdfh(arr[i], \"Text\").match(/(\\d+(?:\\.\\d+)?[gmkb]+.*?)暗网/i)[1],\n        url: pdfh(arr[i], \"a,3&&href\")\n    });\n}\nreturn d;","basicUrl":"https://a.u3c3.life","findAliUrl":"","lastModify":1710426994752,"group":"磁力","author":""},{"name":"U9A9","page":true,"find":"let api = \"/?type=2&search=\" + encodeURIComponent(s) + \"&p=\" + page;\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"table&&.default\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"a&&title\").small(),\n        desc: pdfh(arr[i], \"Text\").match(/\\d+(\\.?\\d+)?\\s[gmkb]+.*/i)[0],\n        url: pdfh(arr[i], \"a,2&&href\")\n    });\n}\nreturn d;","basicUrl":"https://u9a9.one","findAliUrl":"","lastModify":1710426737891,"group":"磁力","author":""},{"name":"Torrent Kitty","page":true,"find":"let api = \"/search/\" + encodeURIComponent(s) + \"/\" + page;\nlet html = request(basicUrl + api);\nlet arr = pdfa(html, \"#archiveResult&&tr:has(a)\");\nlet d = [];\nfor (let i = 0; i < arr.length; i++) {\n    d.push({\n        title: pdfh(arr[i], \"Text\").match(/(.*?)\\d+(?:\\.\\d+)?\\s+?[gmkb]+/i)[1].small(),\n        desc: pdfh(arr[i], \"Text\").match(/(\\d+(?:\\.\\d+)?\\s+?[gmkb]+.*?)详情/i)[1],\n        url: pdfh(arr[i], \"a,1&&href\")\n    });\n}\nreturn d;","basicUrl":"https://cn.torrentkitty.ink","findAliUrl":"","lastModify":1710426724895,"group":"磁力","author":""},{"name":"蛋蛋","find":"let url = basicUrl+\"/page/\"+page + \"/?s=\" + s ;\r\nlet html = fetchPC(url);\r\nlet arr = parseDomForArray(html, \".content&&.excerpt\");\r\nlet bet = [];\r\nfor (let i in arr) {\r\n    let it = arr[i];\r\n    let utitle = pdfh(it, \"h2&&a&&title\");\r\n    let userial = pdfh(it, \"span&&a&&Text\");\r\n    let uimage = pdfh(it, \"img&&src\");\r\n    let u = pd(it, \"h2&&a&&href\", basicUrl);\r\n    bet.push({\r\n        title: utitle,\r\n        url: u,\r\n        pic_url: uimage,\r\n        desc: userial\r\n    });\r\n}\r\nreturn bet;","basicUrl":"https://1tanhua.xyz","findAliUrl":"return pdfh(fetchPC(input), \".article-content&&p,2&&Text\");","page":true,"lastModify":1706690547285,"group":"磁力"},{"name":"TG:阿里云盘发布","find":"basicUrl = basicUrl.split(\"#\");\n\nlet aliUtil = $.require(\"aliUtil\");\n\nlet json = request(basicUrl[0] + \"/api/results/querySource?perPage=10&page=\" + page + \"&sourceName=\" + basicUrl[1] + \"&keyword=\" + encodeURIComponent(s));\nlet list = JSON.parse(json).finalList;\nlet d = [];\nfor (let it of list) {\n    it = it.results;\n    //内置工具，匹配文本中的阿里链接，第二个参数如果是true会匹配多个\n    let url = aliUtil.matchAliUrl(it.text);\n    if (!url) break;\n    d.push({\n        title: it.text,\n        url: url,\n        desc: url\n    });\n}\n\nreturn d;","basicUrl":"https://meow.tg#shareAliyun","findAliUrl":"","page":true,"lastModify":1710337973935,"group":"难用","author":"@LoyDgIk"},{"name":"初音社","find":"let url=basicUrl+\"/wp-json/utils/v2/post_list?s=+\"+encodeURIComponent(s)+\"&page_type=search&paged=\"+page+\"&custom_post_array_down_type%5B%5D=quark&custom_post_array_down_type%5B%5D=aliyun_drive&custom_post_array_down_type%5B%5D=magnet_link\"\nlet json = request(url);\nlet list = JSON.parse(json).posts;\nlet d = [];\nfor (let item of list) {\n    d.push({\n        title: item.post_title,\n        url: item.post_href,\n        pic_url: item.post_image\n    });\n}\nreturn d;","basicUrl":"https://www.mikuclub.win","findAliUrl":"let html = fetch(input);\n\nlet access_password = pdfh(html, \".access_password&&value\");\nlet unzip_password = pdfh(html, \".unzip_password&&value\");\nlet unzip_sub_password = pdfh(html, \".unzip_sub_password&&value\");\nlet durl = pdfh(html, \".download&&href\");\nif (unzip_password || unzip_sub_password) {\n    return new EasyNextPage([{\n        aliUrl: \"copy://\" + unzip_password,\n        title: \"解压密码1：\" + unzip_password,\n    }, {\n        aliUrl: \"copy://\" + unzip_sub_password,\n        title: \"解压密码2\" + unzip_sub_password,\n    }, {\n        aliUrl: durl,\n        title: \"前往网盘\\n\" + durl,\n        sharePwd: access_password\n    }], \"text_1\");\n} else {\n    return {\n        aliUrl: durl,\n        title: \"解压密码2\",\n        sharePwd: access_password\n    };\n}","page":true,"lastModify":1710337976581,"group":"难用","author":"@LoyDgIk"},{"name":"ED3000","author":"","find":"var d = [];\nvar url = basicUrl + `/aliyunpan_video/${s}-${page}-0.html`;\nvar list = pdfa(fetch(url), '.result-wrap&&.resource-item-wrap');\nlist.forEach(item => { \n    d.push({   \n        title: pdfh(item, '.resource-title&&Text'),\n        desc: pdfh(item, '#main,1&&span,-1&&Text') + '\\t' + pdfh(item, '.resource-meta&&.label&&Text').replace('未', ''),\n        url: basicUrl + pdfh(item, 'a&&href'),\n    });\n})\nreturn d","basicUrl":"https://www.ed3000.com","findAliUrl":"return pdfh(fetch(input), '.button-wrap&&a&&href')","page":true,"lastModify":1715691757615,"group":"阿里","ruleType":""},{"name":"又一个资源搜索","author":"","find":"var d = [];\nvar url = basicUrl + `/api/v1/search/${s}/all/${(page-1)*10}`;\nvar list = JSON.parse(fetch(url)).items;\nlist.forEach(item => {\n    d.push({\n        title: item.detail,\n        desc: item.insert_time.replace(/\\.\\d+.*/, ' ').replace('T', ' ') + '\\t' + item.size,\n        url: item.share_url,\n    })\n})\nreturn d","basicUrl":"https://www.so1st.com","findAliUrl":"","page":true,"lastModify":1715691772211,"group":"综合","ruleType":""}]$a@import=js:$.require('import?rule='+"云盘君.简")(input)
    2.