API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：选择器|信息素说我们不可能

xiaomianao666
Apr 28th, 2022
65
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 299.61 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥选择器|信息素说我们不可能@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"#f.File工具\",\"path\":\"File.js\",\"rule\":\"const File = java.io.File;\\nconst {\\n    Files,\\n    Paths,\\n    StandardCopyOption,\\n    StandardOpenOption\\n} = java.nio.file;\\nconst javaString = java.lang.String;\\nlet javaScope = new JavaImporter(java.io, java.lang, java.lang.reflect, java.util.Vector);\\n\\nfunction deleteFlies(fileName) {\\n    let file = new File(fileName);\\n    if (!file.exists()) {\\n        //log(\\\"删除文件失败：\\\" + fileName + \\\"文件不存在\\\");\\n        return false;\\n    } else {\\n        if (file.isFile()) {\\n            return deleteFile(fileName);\\n        } else {\\n            return deleteDirectory(fileName);\\n        }\\n\\n    }\\n\\n}\\n/**\\n * 删除单个文件\\n * \\n * @param fileName\\n *            被删除文件的文件名\\n * @return 单个文件删除成功返回true,否则返回false\\n */\\nfunction deleteFile(fileName) {\\n    let file = new File(fileName);\\n    if (file.isFile() && file.exists()) {\\n        file.delete();\\n        //log(\\\"删除单个文件\\\" + fileName + \\\"成功！\\\");\\n        return true;\\n    } else {\\n        //log(\\\"删除单个文件\\\" + fileName + \\\"失败！\\\");\\n        return false;\\n    }\\n\\n}\\n/**\\n * 删除目录（文件夹）以及目录下的文件\\n * \\n * @param dir\\n *            被删除目录的文件路径\\n * @return 目录删除成功返回true,否则返回false\\n */\\nfunction deleteDirectory(dir) {\\n    // 如果dir不以文件分隔符结尾，自动添加文件分隔符\\n    if (!dir.endsWith(File.separator)) {\\n        dir = dir + File.separator;\\n    }\\n    let dirFile = new File(dir);\\n    // 如果dir对应的文件不存在，或者不是一个目录，则退出\\n    if (!dirFile.exists() || !dirFile.isDirectory()) {\\n        //log(\\\"删除目录失败\\\" + dir + \\\"目录不存在！\\\");\\n        return false;\\n    }\\n    let flag = true;\\n    // 删除文件夹下的所有文件(包括子目录)\\n    let files = dirFile.listFiles();\\n    for (let i = 0; i < files.length; i++) {\\n        // 删除子文件\\n        if (files[i].isFile()) {\\n            flag = deleteFile(files[i].getAbsolutePath());\\n            if (!flag) {\\n                break;\\n            }\\n        } else { // 删除子目录\\n            flag = deleteDirectory(files[i].getAbsolutePath());\\n            if (!flag) {\\n                break;\\n            }\\n        }\\n    }\\n    if (!flag) {\\n        //log(\\\"删除目录失败\\\");\\n        return false;\\n    }\\n    // 删除当前目录\\n    if (dirFile.delete()) {\\n        //log(\\\"删除目录\\\" + dir + \\\"成功！\\\");\\n        return true;\\n    } else {\\n        //log(\\\"删除目录\\\" + dir + \\\"失败！\\\");\\n        return false;\\n    }\\n}\\n\\nfunction getFileTime(path) {\\n    let file = new File(path);\\n    let lastModified = file.lastModified();\\n    let date = new Date(lastModified);\\n    return date.getTime();\\n}\\n\\nfunction getName(path) {\\n    return new File(path).getName() + \\\"\\\";\\n}\\n\\nfunction getFilePath(path, type, expand) {\\n    type = type || \\\"file\\\";\\n    if (![\\\"file\\\", \\\"dir\\\"].includes(type)) throw new Error(\\\"类型错误\\\");\\n    let fileType = type === \\\"file\\\" ? \\\"isFile\\\" : \\\"isDirectory\\\";\\n    let file = new File(path);\\n    let array = file.listFiles() || [];\\n    let pathList = [];\\n    for (let i = 0; i < array.length; i++) {\\n        if (array[i][fileType]()) {\\n            pathList.push({\\n                name: array[i].getName() + \\\"\\\",\\n                path: array[i].getPath() + \\\"\\\"\\n            });\\n        }\\n    }\\n    if (expand) {\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\n    }\\n    return pathList;\\n}\\n\\nfunction renameFile(fromPath, name) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(fromFile.getParent() + \\\"/\\\" + name);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!deleteFlies(toPath)) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction moveFiles(fromPath, toPath) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(toPath);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!deleteFlies(toPath)) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction fileWrite(path, content) {\\n    writeFile(\\\"file://\\\" + path, content)\\n}\\n\\nfunction fileWriteAppend(path, content) {\\n    let file = new File(path);\\n    let paths = file.toPath();\\n    if (file.exists()) {\\n        Files.write(paths, new javaString(content).getBytes(), StandardOpenOption.APPEND);\\n    } else {\\n        writeFile(\\\"file://\\\" + path, content);\\n    }\\n}\\n\\nfunction getTotalSizeOfFilesInDir(file) {\\n    if (file.isFile()) {\\n        return file.length();\\n    }\\n    let children = file.listFiles();\\n    let total = 0;\\n    if (children != null) {\\n        for (let child of children) {\\n            total += getTotalSizeOfFilesInDir(child);\\n        }\\n    }\\n    return total;\\n}\\n\\nfunction getFileSize(filePath) {\\n    //Byte\\n    let size = getTotalSizeOfFilesInDir(new File(filePath));\\n    if (size < 0) {\\n        return null;\\n    }\\n    let unitForm = [\\\"Byte\\\", \\\"KB\\\", \\\"MB\\\", \\\"GB\\\", \\\"TB\\\"];\\n    for (let i = 0, len = unitForm.length; i < len; i++) {\\n        if (size > 1024) {\\n            size /= 1024;\\n            continue;\\n        } else {\\n            return Math.ceil(size) + unitForm[i];\\n        }\\n    }\\n    return \\\"ERROR:数值过大\\\";\\n}\\n//完整合并\\n/*\\nfunction fileCombine(filesInput, fileOut, extension, intercept) {\\n    with(javaScope) {\\n        const TMP_BUFFER_SIZE = 0x30000;\\n        const BUFFER_SIZE = 0x300000;\\n        //合并临时文件\\n        let inputFile = new File(filesInput);\\n        let tmpFile = new File(fileOut + \\\".tmp\\\");\\n        let tos = new BufferedOutputStream(new FileOutputStream(tmpFile));\\n        let inputFiles = inputFile.listFiles();\\n        let tbys = Array.newInstance(Byte.TYPE, TMP_BUFFER_SIZE);\\n        for (let file of inputFiles) {\\n            if (file.getName().endsWith(extension)) {\\n                let is = new FileInputStream(file);\\n                let len = 0;\\n                while ((len = is.read(tbys)) != -1) {\\n                    tos.write(tbys, 0, len);\\n                }\\n                is.close();\\n            }\\n        }\\n        tos.close();\\n        //规则替换规则;\\n        let outFile = new File(fileOut);\\n        if (typeof intercept === \\\"function\\\") {\\n            let tis = new FileInputStream(tmpFile);\\n            let os = new BufferedOutputStream(new FileOutputStream(outFile));\\n            let len = 0;\\n            let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\n            while ((len = tis.read(bys)) != -1) {\\n                let nbys = intercept(new String(bys,0,len));\\n                os.write(nbys, 0, nbys.length);\\n            }\\n            tmpFile.delete();\\n            tis.close();\\n            os.close();\\n        } else {\\n            if (outFile.exists()) {\\n                outFile.delete();\\n            }\\n            tmpFile.renameTo(outFile);\\n        }\\n    }\\n}*/\\n//残\\nfunction fileRule(filesInput, fileOut, intercept) {\\n    with(javaScope) {\\n        const BUFFER_SIZE = 0x300000;\\n        let tmpFile = new File(filesInput);\\n        if(!(tmpFile.exists()&&tmpFile.isFile())){\\n            return false;\\n        }\\n        let outFile = new File(fileOut);\\n\\n        let tis = new FileInputStream(tmpFile);\\n        let os = new BufferedOutputStream(new FileOutputStream(outFile));\\n        let len = 0;\\n        let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\n        while ((len = tis.read(bys)) != -1) {\\n            let nbys = intercept(new String(bys,0,len));\\n            os.write(nbys, 0, nbys.length);\\n        }\\n        tmpFile.delete();\\n        tis.close();\\n        os.close();\\n        return true;\\n    }\\n}\\n\\n$.exports = {\\n    getFileTime: (path) => getFileTime(path),\\n    getFilePath: (path, type, expand) => getFilePath(path, type, expand),\\n    deleteFlies: (path) => deleteFlies(path),\\n    renameFile: (path, name) => renameFile(path, name),\\n    moveFiles: (fromPath, toPath) => moveFiles(fromPath, toPath),\\n    fileWrite: (path, content) => fileWrite(path, content),\\n    fileWriteAppend: (path, content) => fileWriteAppend(path, content),\\n    getName: (path) => getName(path),\\n    getFileSize: (filePath) => getFileSize(filePath),\\n    fileRule: (filesInput, fileOut, intercept) => fileRule(filesInput, fileOut, intercept)\\n}\"},{\"col_type\":\"text_2\",\"name\":\"#v.下载列表-普通下载\",\"path\":\"download.view\",\"rule\":\"js:\\nconst viewConfig = Object.assign({\\n    chapterList: [],\\n    info: {},\\n    defaultView: \\\"0\\\"\\n}, MY_PARAMS);\\nviewConfig.info = Object.assign({\\n    ruleName: \\\"\\\",\\n    bookName: \\\"\\\",\\n    bookTopPic: \\\"\\\",\\n    parseCode: \\\"\\\",\\n    type: \\\"comic\\\",\\n}, viewConfig.info);\\nlet {\\n    chapterList,\\n    info,\\n    defaultView\\n} = viewConfig;\\nsetPageTitle(\\\"选择器|\\\" + info.bookName)\\n\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nconst def_DoVi_Style = Config.def_DoVi_Style;\\nconst MY_ID = info.ruleName + \\\"//\\\" + info.bookName;\\n\\n\\nlet isStart = getMyVar(MY_ID + \\\":isStart\\\");\\nlet viewMode = getMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\nlet isReverse = getMyVar(MY_ID + \\\":isReverse\\\", \\\"0\\\");\\nlet tagFilter = getMyVar(MY_ID + \\\":tagFilter\\\", Config.def_DoVi_Type);\\n\\naddListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n    clearMyVar(MY_ID + \\\":loadingTeam\\\");\\n    clearMyVar(MY_ID + \\\":viewMode\\\");\\n    clearMyVar(MY_ID + \\\":completed\\\");\\n    clearMyVar(MY_ID + \\\":batchTeam\\\");\\n    clearMyVar(MY_ID + \\\":tagFilter\\\");\\n    clearMyVar(MY_ID + \\\":pageNum\\\");\\n}, MY_ID));\\n\\nlet layout = [];\\n\\nif (isStart === \\\"1\\\") {\\n    putMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\n    viewMode = \\\"1\\\";\\n}\\n\\nlet backupChapterList = chapterList;\\nif (typeof chapterList === \\\"string\\\") {\\n    chapterList = JSON.parse(request(\\\"file://\\\" + chapterList) || \\\"[]\\\");\\n}\\nlet chapterAll = chapterList;\\nchapterList = chapterList.map((item, CID) => {\\n    item.CID = CID;\\n    return item;\\n});\\nlet pageNum = Number(getMyVar(MY_ID + \\\":pageNum\\\", \\\"1\\\"));\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\nchapterList = chapterChunk[pageNum] || [];\\n\\nfunction setType() {\\n    let set = (tag, put) => {\\n        putMyVar(put, tag);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    };\\n    layout.push({\\n        title: 0 == pageNum ? \\\"““””\\\" + (\\\"全部(\\\" + chapterAll.length + \\\")\\\").fontcolor(\\\"#23AD6F\\\") : \\\"全部(\\\" + chapterAll.length + \\\")\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, 0, MY_ID + \\\":pageNum\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    for (let i = 1; i < chapterChunk.length; i++) {\\n        let tagText = (i - 1) * Config.viewPageSize + \\\"-\\\" + ((i - 1) * Config.viewPageSize + chapterChunk[i].length);\\n        layout.push({\\n            title: i == pageNum ? \\\"““””\\\" + tagText.fontcolor(\\\"#23AD6F\\\") : tagText,\\n            url: $(\\\"#noLoading#\\\").lazyRule(set, i, MY_ID + \\\":pageNum\\\"),\\n            col_type: \\\"scroll_button\\\"\\n        });\\n    }\\n    layout.push({\\n        col_type: \\\"blank_block\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"0\\\" ? \\\"““””\\\" + \\\"全部\\\".fontcolor(\\\"#23AD6F\\\") : \\\"全部\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"0\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"1\\\" ? \\\"““””\\\" + \\\"未下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"未下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"1\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"2\\\" ? \\\"““””\\\" + \\\"已下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"已下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"2\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n}\\nlet chapterTeam = [];\\nlet record = [];\\nif (info.type === \\\"comic\\\") {\\n    let lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        let filelist = File.getFilePath(input);\\n        let piclist = filelist.map((item, i) => \\\"file://\\\" + input + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n        return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n    });\\n\\n    function comFun(i, item) {\\n        let rootPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title;\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: rootPath + lazy,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"dir\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2]);\\n        }\\n    });\\n} else {\\n    function comFun(i, item) {\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n                path: Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title + \\\".txt\\\",\\n                title: item.title\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"file\\\", \\\".txt\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\".\\\")));\\n        }\\n    });\\n}\\n\\nfunction clickDownload(item, info, MY_ID, i) {\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = loadingTeam.indexOf(i);\\n    if (ElementIndex > -1) return \\\"toast://正在下载\\\";\\n\\n    loadingTeam.push(i);\\n    putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    updateItem({\\n        title: \\\"‘‘\\\" + item.title + \\\"’’\\\",\\n        extra: {\\n            id: MY_ID + \\\"#\\\" + i\\n        }\\n    });\\n    let result = \\\"toast://下载失败\\\";\\n    try {\\n        toast(\\\"开始下载:\\\" + item.title);\\n        let download = $.require(\\\"hiker://page/Download.exe.js\\\");\\n        result = download(item, info, MY_ID, i);\\n        updateItem({\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"toast://已下载\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n    } catch (e) {\\n        updateItem({\\n            title: item.title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        log(e.toString());\\n    } finally {\\n        loadingTeam.splice(ElementIndex, 1);\\n        putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    }\\n    return result;\\n}\\n\\nfunction singleView() {\\n    layout.push({\\n        title: \\\"反转列表\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((isReverse, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, isReverse, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    layout.push({\\n        title: \\\"批量下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            if (loadingTeam.length > 0) return \\\"toast://还有任务没有完成\\\";\\n            if (getAppVersion() < 2594) return \\\"toast://未开放\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"1\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n\\n        }, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: loadingTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n}\\n\\nfunction clickChoose(title, MY_ID, i) {\\n    let isStart = getMyVar(MY_ID + \\\":isStart\\\");\\n    if (isStart === \\\"1\\\") return \\\"toast://正在下载...\\\";\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = batchTeam.indexOf(i);\\n    if (ElementIndex > -1) {\\n        updateItem({\\n            title: title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.splice(ElementIndex, 1);\\n    } else {\\n        updateItem({\\n            title: \\\"‘‘\\\" + title + \\\"’’\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.push(i);\\n    }\\n    putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n    return \\\"hiker://empty\\\";\\n}\\n\\nfunction batchView() {\\n    layout.push({\\n        title: \\\"单选下载\\\",\\n        pic_url: \\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在批量下载\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"0\\\");\\n            clearMyVar(MY_ID + \\\":batchTeam\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\n    let end = start + chapterList.length;\\n    layout.push({\\n        title: \\\"选择全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = Tool.range(start, end);\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\":completed\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"取消全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = new Set(Tool.range(start, end));\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"确认选中\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\", \\\"-1\\\") !== \\\"-1\\\") {\\n                return \\\"toast://正在下载...\\\";\\n            }\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            return batchTeam.length === 0 ? \\\"toast://你还什么都没有选\\\" : \\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\";\\n        }, MY_ID),\\n        extra: {\\n            newWindow: true,\\n            windowId: MY_ID + \\\"//批量下载\\\",\\n            MY_ID: MY_ID,\\n            chapterList: backupChapterList,\\n            info: info\\n        },\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let completed = [];\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            completed.push(item.CID);\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: batchTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n    putMyVar(MY_ID + \\\":completed\\\", JSON.stringify(completed));\\n}\\nswitch (viewMode) {\\n    case \\\"0\\\":\\n        singleView();\\n        break;\\n    case \\\"1\\\":\\n        batchView();\\n        break;\\n}\\nif (isReverse === \\\"1\\\") {\\n    chapterTeam.reverse();\\n}\\nlayout.push.apply(layout, chapterTeam);\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.批量下载器\",\"path\":\"Batch.view\",\"rule\":\"js:\\nlet {\\n    chapterList,\\n    info,\\n    MY_ID\\n} = MY_PARAMS;\\nsetPageTitle(\\\"下载器|\\\"+info.bookName);\\naddListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n    clearMyVar(MY_ID + \\\":isStart\\\");\\n    clearMyVar(MY_ID + \\\":status\\\");\\n    clearMyVar(MY_ID + \\\":batchTeam\\\");\\n    refreshPage();\\n}, MY_ID));\\n\\nlet isStart = getMyVar(MY_ID + \\\":isStart\\\", \\\"0\\\");\\nlet status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\nlet layout = [];\\n\\nlet batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\nif(typeof chapterList === \\\"string\\\"){\\n    chapterList = JSON.parse(request(\\\"file://\\\"+chapterList)||\\\"[]\\\");\\n}\\nlet chapterTeam = batchTeam.map(v => {\\n    let chapterItem = chapterList[v];\\n    chapterItem.CID = v;\\n    return chapterItem;\\n});\\nif (isStart === \\\"0\\\") {\\n    layout.push({\\n        title: \\\"开始下载[\\\" + chapterTeam.length + \\\"]\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((chapterTeam, info, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isStart\\\", \\\"1\\\");\\n            refreshPage(false);\\n            let download = $.require(\\\"hiker://page/BatchStatistics.js\\\");\\n            return download(chapterTeam, info, MY_ID) || \\\"toast://下载错误\\\";\\n        }, chapterTeam, info, MY_ID),\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"||开始下载\\\"\\n        }\\n    });\\n    layout.push({\\n        title: \\\"任务列表：\\\",\\n        col_type: \\\"rich_text\\\",\\n    });\\n    for (let item of chapterTeam) {\\n        layout.push({\\n            title: item.title,\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_2\\\"\\n        });\\n    }\\n\\n} else {\\n    layout.push({\\n        title: \\\"下载进度:0/\\\"+chapterTeam.length,\\n        desc: \\\"““””▇▇▇▇▇▇▇▇▇▇\\\".fontcolor(\\\"#e5e1e4\\\")+\\\" 0%\\\",\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"||下载进度\\\",\\n            lineVisible: false\\n        }\\n    });\\n    layout.push({\\n        title: \\\"后台下载\\\",\\n        url: \\\"func://background\\\",\\n        col_type: \\\"text_2\\\"\\n    });\\n\\n    layout.push({\\n        title: [\\\"[取消下载]\\\", \\\"[正在停止...]\\\", \\\"[返回]\\\", \\\"[处理失败]\\\", \\\"[重新开始]\\\"][status],\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n            if (status === \\\"0\\\") {\\n                putMyVar(MY_ID + \\\":status\\\", \\\"1\\\");\\n                updateItem({\\n                    title: \\\"[正在停止...]\\\",\\n                    extra: {\\n                        id: MY_ID + \\\"||下载控制\\\"\\n                    }\\n                });\\n                return \\\"toast://正在取消下载任务\\\";\\n            } else if (status === \\\"1\\\") {\\n                return \\\"toast://正在暂停...\\\";\\n            } else if (status === \\\"2\\\") {\\n                back();\\n                return \\\"toast://已退出下载器\\\";\\n            } else if ([\\\"3\\\", \\\"4\\\"].includes(status)) {\\n                clearMyVar(MY_ID + \\\":isStart\\\");\\n                clearMyVar(MY_ID + \\\":status\\\");\\n                clearMyVar(MY_ID + \\\":log\\\");\\n                refreshPage();\\n                return \\\"toast://重新点击下载\\\"\\n            }\\n        }, MY_ID),\\n        col_type: \\\"text_2\\\",\\n        extra: {\\n            id: MY_ID + \\\"||下载控制\\\"\\n        }\\n    });\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    layout.push({\\n        title: \\\"<strong>下载日志</strong>\\\".big(),\\n        col_type: \\\"rich_text\\\",\\n        \\n    });\\n    layout.push({\\n        col_type: \\\"line\\\",\\n        extra: {\\n            id: MY_ID + \\\"||日志\\\"\\n        }\\n    });\\n    layout.push({\\n        title:\\\"““””$>\\\"+\\\"开始下载......\\\".fontcolor(\\\"#00ff00\\\"),\\n        url:\\\"hiker://empty\\\",\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"#log#0\\\",\\n            lineVisible:false\\n        }\\n    });\\n}\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.批量下载统计\",\"path\":\"BatchStatistics.js\",\"rule\":\"const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nfunction task(taskParam) {\\n    let result = $.require(\\\"hiker://page/Batch.exe.js\\\")(taskParam);\\n    return result;\\n}\\n\\n$.exports = function(chapterTeam, info, MY_ID) {\\n    if (chapterTeam.length === 0) {\\n        return \\\"toast://空的下载队列\\\";\\n    }\\n    var count = 0;\\n    var taskCount = chapterTeam.length;\\n    var successCID = [];\\n    var failName = [];\\n    var logCount = 1;\\n    var taskTeam = chapterTeam.map(chapterItem => ({\\n        func: task,\\n        id: chapterItem.title,\\n        param: {\\n            chapterItem: chapterItem,\\n            info: info,\\n            MY_ID: MY_ID\\n        }\\n    }));\\n    let logNum = Config.logNum;\\n\\n    function putLog(text) {\\n        log(text);\\n        if (logCount >= logNum) {\\n            deleteItem(MY_ID + \\\"#log#\\\" + (logCount - 10));\\n        }\\n        addItemAfter(MY_ID + \\\"||日志\\\", {\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"$>\\\" + text,\\n            col_type: \\\"text_1\\\",\\n            extra: {\\n                lineVisible: false,\\n                id: MY_ID + \\\"#log#\\\" + logCount\\n            }\\n        });\\n        logCount++;\\n    }\\n\\n    function listener(perch, id, error, CID) {\\n        count++;\\n        let isSuccess = false;\\n        if (error !== null) {\\n            failName.push(id);\\n            putLog(\\\"[listener]下载失败：\\\" + id + \\\"<ERROR@ \\\" + error + \\\">\\\");\\n        } else if (CID >= 0) {\\n            successCID.push(CID);\\n            let ratio = (count / taskCount).toFixed(4);\\n            let stripCount = Math.ceil(ratio * 10);\\n            isSuccess = true;\\n            updateItem({\\n                title: \\\"下载进度：\\\" + successCID.length + \\\"/\\\" + taskCount,\\n                desc: \\\"““””\\\" + \\\"▇\\\".repeat(stripCount).fontcolor(\\\"#ffac2d\\\") + \\\"▇\\\".repeat(10 - stripCount).fontcolor(\\\"#e5e1e4\\\") + \\\" \\\" + (ratio * 100) + \\\"%\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载进度\\\"\\n                }\\n            });\\n            putLog(\\\"[listener]已完成下载：\\\" + id);\\n        } else if (CID === -1) {\\n            failName.push(id);\\n            putLog(\\\"[listener]已停止：\\\" + id);\\n        }\\n        if (taskCount !== count) return;\\n        if (successCID.length === taskCount) {\\n            updateItem({\\n                desc: \\\"““””\\\" + \\\"▇\\\".repeat(10).fontcolor(\\\"#00ff00\\\") + \\\" 100%\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载进度\\\"\\n                }\\n            });\\n        }\\n        let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n        let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n        let failTeam = batchTeam.filter(v => !successCID.includes(v));\\n        putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(failTeam));\\n        if (failTeam.length > 0 && status !== \\\"1\\\") {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"3\\\");\\n            putLog(\\\"下载失败:[\\\" + failName.join(\\\"]，[\\\") + \\\"]。\\\");\\n            updateItem({\\n                title: \\\"[处理失败]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        } else if (failTeam.length > 0 && status === \\\"1\\\") {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"4\\\");\\n            putLog(\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\");\\n            updateItem({\\n                title: \\\"[重新开始]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        } else {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"2\\\");\\n            putLog(\\\"下载任务[\\\" + info.bookName + \\\"]已全部成功完成\\\");\\n            updateItem({\\n                title: \\\"[返回]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        }\\n        toast(\\\"下载任务[\\\" + info.bookName + \\\"]已完成\\\");\\n    }\\n    let taskTeamChunk = [];\\n    if (Config.threadNum > 0) {\\n        taskTeamChunk = Tool.chunk(taskTeam, Config.threadNum);\\n    } else {\\n        taskTeamChunk = [taskTeam];\\n    }\\n    for (let taskList of taskTeamChunk) {\\n        be(taskList, {\\n            func: listener\\n        });\\n        let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n        if (status === \\\"1\\\") {\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n            let failTeam = batchTeam.filter(v => !successCID.includes(v));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(failTeam));\\n            putMyVar(MY_ID + \\\":status\\\", \\\"4\\\");\\n            putLog(\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\");\\n            updateItem({\\n                title: \\\"[重新开始]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n            return \\\"hiker://empty\\\";\\n        }\\n\\n    }\\n\\n    return \\\"hiker://empty\\\";\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.批量主程序\",\"path\":\"Batch.exe.js\",\"rule\":\"const File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n\\nfunction comic(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n        return -1;\\n    }\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + chapterItem.CID + \\\"$B$\\\" + chapterItem.title + \\\"/\\\";\\n    let picList;\\n    try {\\n        let getPicList = new Function(\\\"input\\\", \\\"url\\\", \\\"return \\\" + info.parseCode);\\n        picList = getPicList(chapterItem.url, chapterItem.url);\\n        if (typeof picList === \\\"string\\\") {\\n            picList = picList.replace(\\\"pics://\\\", \\\"\\\").split(\\\"&&\\\");\\n        }\\n    } catch (e) {\\n        e.message = \\\"<漫画图片解析错误：\\\" + e.message + \\\">\\\";\\n        throw e;\\n    }\\n    const L = picList.length;\\n    if(L===0){\\n        throw new Error(\\\"<漫画图片解析错误：图片链接返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误：\\\" + e.message + \\\">\\\");\\n        }\\n    }\\n    var schedule = new Map([\\n        [L, () => log(chapterItem.title + \\\"已下载100%\\\")],\\n        [~~(0.90 * L), () => log(chapterItem.title + \\\"已下载90%+\\\")],\\n        [~~(0.75 * L), () => log(chapterItem.title + \\\"已下载75%+\\\")],\\n        [~~(0.50 * L), () => log(chapterItem.title + \\\"已下载50%+\\\")],\\n        [~~(0.25 * L), () => log(chapterItem.title + \\\"已下载25%+\\\")]\\n    ]);\\n    for (var i = 0; i < L; i++) {\\n        let pic = Tool.hikerPic(picList[i]);\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\".jpg\\\", pic[1]);\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\n        if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n            return -1;\\n        }\\n    }\\n    File.renameFile(chapterPath, chapterItem.CID + \\\"$A$\\\" + chapterItem.title);\\n    return chapterItem.CID;\\n}\\n\\nfunction novel(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n        return -1;\\n    }\\n    let mainPath = Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + chapterItem.CID + \\\"$A$\\\" + chapterItem.title + \\\".txt\\\";\\n    let content = \\\"\\\";\\n    try {\\n        let getContent = new Function(\\\"input\\\", \\\"url\\\", \\\"return \\\" + info.parseCode);\\n        content = getContent(chapterItem.url, chapterItem.url);\\n    } catch (e) {\\n        e.message = \\\"<小说正文解析错误：\\\" + e.message + \\\">\\\";\\n        throw e;\\n    }\\n    if (!content) {\\n        throw new Error(\\\"<小说正文解析错误：正文返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误：\\\" + e.message + \\\">\\\");\\n        }\\n    }\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\/script>/gmi, \\\"\\\").trimRight());\\n    //File.renameFile(chapterPath, chapterItem.CID + \\\"$A$\\\" + chapterItem.title);\\n    return chapterItem.CID;\\n}\\nvar $exe = {\\n    comic: comic,\\n    novel: novel\\n};\\n$.exports = function(taskParam) {\\n    return $exe[taskParam.info.type](taskParam);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.普通主程序\",\"path\":\"Download.exe.js\",\"rule\":\"const File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n\\nfunction novel(item, info, MY_ID, order) {\\n    let mainPath = Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$A$\\\" + item.title + \\\".txt\\\";\\n    let content = \\\"\\\";\\n    try {\\n        let getContent = new Function(\\\"input\\\", \\\"url\\\", \\\"return \\\" + info.parseCode);\\n        content = getContent(item.url, item.url) || \\\"\\\";\\n    } catch (e) {\\n        e.message = \\\"<小说正文解析错误> \\\" + e.message;\\n        throw e;\\n    }\\n    if (!content) {\\n        toast(\\\"小说为空\\\");\\n        throw new Error(\\\"<小说正文解析错误：正文返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\/script>/gmi, \\\"\\\").trimRight());\\n    //File.renameFile(chapterPath, order + \\\"$A$\\\" + item.title + \\\".txt\\\");\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\n\\nfunction comic(item, info, MY_ID, order) {\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$B$\\\" + item.title + \\\"/\\\";\\n    let picList = [];\\n    try {\\n        let getPicList = new Function(\\\"input\\\", \\\"return\\\" + info.parseCode);\\n        picList = getPicList(item.url);\\n        if (typeof picList === \\\"string\\\") {\\n            picList = picList.replace(\\\"pics://\\\", \\\"\\\").split(\\\"&&\\\");\\n        }\\n    } catch (e) {\\n        e.message = \\\"<漫画图片解析错误> \\\" + e.message;\\n        throw e;\\n    }\\n\\n    const L = picList.length;\\n    if(L===0){\\n        toast(\\\"图片链接为空\\\");\\n        throw new Error(\\\"<漫画图片解析错误：图片链接返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n    var schedule = new Map([\\n        [L, () => log(item.title + \\\"已下载100%\\\")],\\n        [~~(0.90 * L), () => log(item.title + \\\"已下载90%+\\\")],\\n        [~~(0.75 * L), () => log(item.title + \\\"已下载75%+\\\")],\\n        [~~(0.50 * L), () => log(item.title + \\\"已下载50%+\\\")],\\n        [~~(0.25 * L), () => log(item.title + \\\"已下载25%+\\\")]\\n    ]);\\n\\n    for (var i = 0; i < L; i++) {\\n        let pic = Tool.hikerPic(picList[i]);\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\".jpg\\\", pic[1]);\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\n    }\\n\\n    File.renameFile(chapterPath, order + \\\"$A$\\\" + item.title);\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\nvar $exe = {\\n    comic: comic,\\n    novel: novel\\n};\\n$.exports = function(item, info, MY_ID, order) {\\n    return $exe[info.type](item, info, MY_ID, order);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#f.通用工具\",\"path\":\"Tool.js\",\"rule\":\"$.exports = {\\n    split(text, target, count) {\\n        count = count === undefined ? 1 : count;\\n        let array = [text];\\n        for (let i = 0; i < count; i++) {\\n            text = array[i];\\n            let index = text.indexOf(target);\\n            if (index === -1) {\\n                break;\\n            }\\n            array[i] = text.slice(0, index);\\n            array[i + 1] = text.slice(index + target.length);\\n        }\\n        return array;\\n    },\\n    chunk(arr, size) {\\n        var result = [];\\n        for (var i = 0, len = arr.length; i < len; i += size) {\\n            result.push(arr.slice(i, i + size));\\n        }\\n        return result;\\n    },\\n    hikerPic(url) {\\n        var headers = {};\\n        let urls = url.split(\\\"@\\\");\\n        let picUrl = urls.shift();\\n        let length = urls.length;\\n        for (let i = 0; i < length; i++) {\\n            let [key, value] = urls[i].split(\\\"=\\\");\\n            headers[key] = value;\\n        }\\n        return [picUrl, headers];\\n    },\\n    range(start, end) {\\n        return Array(end - start).fill(0).map((el, i) => start + i);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#j.Config\",\"path\":\"Config.json\",\"rule\":\"const Config = Object.assign({\\n    homePath: \\\"/storage/emulated/0/Android/data/com.example.hikerview/files/Documents/localManager\\\",\\n    logNum: 10,\\n    threadNum: 16,\\n    def_isPaginate: \\\"1\\\", //1默认开启分页，0默认关闭\\n    viewPageSize: 200,\\n    def_Pic: \\\"hiker://images/home_pic4\\\",\\n    def_Lord_Type: \\\"comic\\\",\\n    def_View_Style: \\\"text_1\\\",\\n    def_DoVi_Style: \\\"text_2\\\",\\n    def_DoVi_Type: \\\"1\\\", //0全部, 1未完成，2已完成\\n}, JSON.parse(readFile(\\\"config.json\\\") || \\\"{}\\\"));\\nconst PATHS = {\\n    novelPath: \\\"/小说/\\\",\\n    comicPath: \\\"/漫画/\\\",\\n    novelFullPath: \\\"/小说合并/\\\"\\n}\\n\\n\\nObject.keys(PATHS).forEach(key => Config[key] = Config.homePath + PATHS[key]);\\n$.exports = Config;\"},{\"col_type\":\"movie_3\",\"name\":\"#v.主页面\",\"path\":\"Main.view\",\"rule\":\"js:\\nfunction main() {\\n    var layout = [];\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n    const Config = $.require(\\\"hiker://page/Config.json\\\");\\n    let type = getMyVar(\\\".type\\\", Config.def_Lord_Type);\\n    let tag = File.getFilePath(Config[type + \\\"Path\\\"], \\\"dir\\\");\\n    let tgnum = getMyVar(\\\".tgnum\\\", \\\"0\\\");\\n    addListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n        clearMyVar(\\\"searchKey\\\");\\n        clearMyVar(\\\".tgnum\\\");\\n    }));\\n    layout.push({\\n        title: type === \\\"comic\\\" ? \\\"◉漫画\\\" : \\\"○漫画\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((type) => {\\n            if (type === \\\"comic\\\") return \\\"hiker://empty\\\";\\n            putMyVar(\\\".type\\\", \\\"comic\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_2\\\",\\n    });\\n    layout.push({\\n        title: type === \\\"novel\\\" ? \\\"◉小说\\\" : \\\"○小说\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((type) => {\\n            if (type === \\\"novel\\\") return \\\"hiker://page/NovelCollected.view#noRecordHistory##noHistory#\\\";\\n            putMyVar(\\\".type\\\", \\\"novel\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_2\\\",\\n    });\\n    if (tag.length === 0) {\\n        layout.push({\\n            title: \\\"““””\\\" + \\\"一本也没有\\\".big(),\\n            url: \\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                version: MY_RULE.version,\\n                lineVisible: false\\n            }\\n        })\\n        return setResult(layout);\\n    }\\n    layout.push({\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        desc: \\\"搜你想要的#\\\" + type + \\\"#......\\\",\\n        title: '搜索',\\n        col_type: 'input',\\n        extra: {\\n            rules: $.toString((tag, type) => {\\n                let arr1 = [];\\n                for (let i = 0; i < tag.length; i++) {\\n                    arr1.push({\\n                        \\\"title\\\": tag[i].name,\\n                        \\\"search_url\\\": \\\"hiker://empty?isAll=1&searchTerms=**&type=\\\" + type,\\n                        \\\"searchFind\\\": \\\"js:$.require('hiker://page/Search.view?rule='+MY_RULE._title);\\\"\\n                    });\\n                }\\n\\n                return JSON.stringify(arr1);\\n            }, tag, type),\\n            defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"\\n        }\\n    });\\n    \\n    layout.push({\\n        title: \\\"‘‘⚙设置’’\\\",\\n        col_type: \\\"scroll_button\\\",\\n        url: \\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\",\\n        extra:{\\n            version: MY_RULE.version\\n        }\\n    });\\n    \\n\\n    for (let i in tag) {\\n        let it = tag[i];\\n        if (tgnum === i) {\\n            layout.push({\\n                title: \\\"““\\\" + it.name + \\\"””\\\",\\n                col_type: \\\"scroll_button\\\",\\n                url: $U.build($U([\\\"删除该目录\\\", \\\"跳转小程序\\\"], 1, \\\"选择操作\\\").select((name) => {\\n                    if (\\\"跳转小程序\\\" === input) {\\n                        return \\\"hiker://home@\\\" + name;\\n                    } else {\\n                        return then([\\\"该操作不会删除小程序，但该小程序下载的所有漫画将被删除\\\"]);\\n                    }\\n                }, it.name).confirm((path) => {\\n                    const File = $.require(\\\"hiker://page/File.js\\\");\\n                    if (File.deleteFlies(path)) {\\n                        clearMyVar(\\\".tgnum\\\");\\n                        refreshPage();\\n                        return \\\"toast://删除成功\\\";\\n                    } else {\\n                        return \\\"toast://删除失败\\\";\\n                    }\\n                }, it.path))\\n            });\\n        } else {\\n            layout.push({\\n                title: it.name,\\n                col_type: \\\"scroll_button\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule(i => {\\n                    putMyVar(\\\".tgnum\\\", i);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }, i),\\n            });\\n        }\\n    }\\n    let path = tag[tgnum].path;\\n    let mhlist = File.getFilePath(path, \\\"dir\\\");\\n\\n    if (mhlist.length === 0) {\\n        layout.push({\\n            title: \\\"““””\\\" + \\\"一本也没有\\\".big(),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        })\\n        return setResult(layout);\\n    }\\n    let pageUrl = type === \\\"novel\\\" ? \\\"hiker://page/NovelBrowser.view\\\" : \\\"hiker://page/ComicBrowser.view\\\";\\n    for (let item of mhlist) {\\n        let pic = fileExist(\\\"file://\\\" + item.path + \\\"/\\\" + item.name + \\\".jpg\\\") ? item.path + \\\"/\\\" + item.name + \\\".jpg\\\" : Config.def_Pic;\\n        layout.push({\\n            title: item.name,\\n            pic_url: pic,\\n            url: pageUrl + \\\"?rule=\\\" + MY_RULE.title,\\n            extra: item\\n        });\\n    }\\n    setResult(layout);\\n}\\nmain();\"},{\"col_type\":\"text_1\",\"name\":\"#v.漫画查看\",\"path\":\"ComicBrowser.view\",\"rule\":\"js:\\nif (getParam(\\\"hasParams\\\") === \\\"true\\\") {\\n    MY_PARAMS = {\\n        path: decodeURIComponent(getParam(\\\"path\\\")),\\n        name: decodeURIComponent(getParam(\\\"name\\\"))\\n    }\\n}\\nlet path = MY_PARAMS.path;\\nsetPageTitle(\\\"CV|\\\" + MY_PARAMS.name)\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nvar layout = [];\\nlet mode = getMyVar(\\\".mode\\\", \\\"0\\\");\\nlet isReverse = getMyVar(\\\".isReverse\\\", \\\"0\\\");\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\".mode\\\");\\n    clearMyVar(\\\".isReverse\\\");\\n}));\\nconst comicStatus=new Map([[\\\"A\\\",\\\"\\\"],[\\\"B\\\",\\\"‘‘[未完成]’’\\\"]]);\\nfunction getTitle(title) {\\n    let titles = Tool.split(title, \\\"$\\\", 2);\\n    return comicStatus.get(titles[1])+titles[2] || title;\\n}\\nlayout.push({\\n    title: \\\"删除整本\\\",\\n    url: $(\\\"确认删除整本漫画？\\\").confirm((path) => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFlies(path)) {\\n            back();\\n            return \\\"toast://删除成功\\\";\\n        } else {\\n            return \\\"toast://删除失败\\\";\\n        }\\n    }, path),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    title: [\\\"看漫画\\\", \\\"删除章节\\\"][mode],\\n    url: $(\\\"#noLoading#\\\").lazyRule((mode) => {\\n        putMyVar(\\\".mode\\\", mode === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage(true);\\n        return \\\"hiker://empty\\\"\\n    }, mode),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n})\\nlet mhlist = File.getFilePath(path, \\\"dir\\\");\\nmhlist.sort((a, b) => {\\n    a = (a.name.match(/\\\\d+/) || [])[0] || 0;\\n    b = (b.name.match(/\\\\d+/) || [])[0] || 0;\\n    return a - b;\\n});\\n\\nlayout.push({\\n    title: \\\"““””\\\" + \\\"章节 \\\".big() + (\\\"共有:\\\" + mhlist.length + \\\"章\\\").small(),\\n    url: $(\\\"#noLoading#\\\").lazyRule((isReverse) => {\\n        putMyVar(\\\".isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage(true);\\n        return \\\"hiker://empty\\\"\\n    }, isReverse),\\n    col_type: \\\"text_1\\\"\\n});\\nlet array = [];\\nlet lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n    let filelist = File.getFilePath(input);\\n    let piclist = filelist.map((item, i) => \\\"file://\\\" + input + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n    return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n})\\nif (mode === \\\"0\\\") {\\n    for (let item of mhlist) {\\n        array.push({\\n            title: getTitle(item.name),\\n            url: item.path+lazy,\\n            col_type: Config.def_View_Style\\n        });\\n    }\\n} else {\\n    for (let item of mhlist) {\\n        let name = getTitle(item.name);\\n        array.push({\\n            title: name,\\n            url: $(\\\"确认删除[\\\" + name + \\\"]？\\\").confirm((path) => {\\n                const File = $.require(\\\"hiker://page/File.js\\\");\\n                if (File.deleteFlies(path)) {\\n                    refreshPage(true);\\n                    return \\\"toast://删除成功\\\";\\n                } else {\\n                    return \\\"toast://删除失败\\\";\\n                }\\n            }, item.path),\\n            col_type: Config.def_View_Style\\n        });\\n    }\\n}\\nif (isReverse === \\\"1\\\") {\\n    array.reverse();\\n}\\nlayout.push.apply(layout, array);\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.聚合搜索\",\"path\":\"Search.view\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js?rule=\\\" + MY_RULE._title);\\nconst Config = $.require(\\\"hiker://page/Config.json?rule=\\\" + MY_RULE._title);\\nlet comicRuleDirs = File.getFilePath(Config[getParam(\\\"type\\\")+\\\"Path\\\"], \\\"dir\\\");\\nif (getParam(\\\"isAll\\\") === \\\"1\\\") {\\n    comicRuleDirs = comicRuleDirs.filter(item => item.name === MY_RULE.title);\\n}\\n\\nlet searchResult = [];\\nlet searchTerms = getParam(\\\"searchTerms\\\");\\nlet termsArr = searchTerms.split(\\\"\\\").map(t => t.replace(/\\\\*|\\\\.|\\\\?|\\\\+|\\\\$|\\\\^|\\\\[|\\\\]|\\\\(|\\\\)|\\\\{|\\\\}|\\\\||\\\\/|\\\\\\\\/g, k => \\\"\\\\\\\\\\\" + k));\\nlet reg = new RegExp(termsArr.join(\\\".*\\\"),\\\"i\\\");\\nlet pageUrl=getParam(\\\"type\\\")===\\\"novel\\\"?\\\"hiker://page/NovelBrowser.view\\\":\\\"hiker://page/ComicBrowser.view\\\";\\nfor (let sonDir of comicRuleDirs) {\\n    let comicList = File.getFilePath(sonDir.path, \\\"dir\\\");\\n    for (let comic of comicList) {\\n        if (reg.test(comic.name)) {\\n            searchResult.push({\\n                title: comic.name,\\n                pic_url: comic.path + \\\"/\\\" + comic.name + \\\".jpg\\\",\\n                url: pageUrl+\\\"?rule=\\\" + MY_RULE._title,\\n                desc: sonDir.name,\\n                extra: comic\\n            });\\n        }\\n    }\\n\\n}\\nsetResult(searchResult);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.设置\",\"path\":\"Setting.view\",\"rule\":\"js:\\nsetPageTitle(MY_RULE.title + \\\"|设置\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nlet layout = [];\\n\\nlayout.push({\\n    title: \\\"<strong>基础设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"目录路径\\\",\\n    url: $(Config.homePath, \\\"支持hiker://files路径\\\\n(该操作不会初始化目录)\\\").input(() => {\\n        const Config = $.require(\\\"hiker://page/Config.json\\\");\\n        if (input.startsWith(\\\"hiker://files/\\\")) input = getPath(input).slice(7);\\n        if (Config.homePath == input) return \\\"toast://已经是当前目录\\\";\\n        Config = JSON.parse(readFile(\\\"config.json\\\") || \\\"{}\\\");\\n        Config.homePath = input;\\n        saveFile(\\\"config.json\\\", JSON.stringify(Config));\\n        refreshPage(false);\\n        return \\\"toast://已保存\\\";\\n    }),\\n    desc: Config.homePath,\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"设置默认封面\\\",\\n    desc: Config.def_Pic,\\n    url: \\\"hiker://page/Setting/More.view#noRefresh##noRecordHistory##noHistory#?settingType=defaultPic\\\",\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"<strong>下载器设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nfunction setNum(key, test) {\\n    let Config = JSON.parse(readFile(\\\"config.json\\\") || \\\"{}\\\");\\n    input = parseInt(input);\\n    if (Number.isNaN(input)) return \\\"toast://请输入数字\\\";\\n    if (!test(input)) return \\\"toast://不符合条件\\\";\\n    Config[key] = input;\\n    saveFile(\\\"config.json\\\", JSON.stringify(Config));\\n    refreshPage(false);\\n    return \\\"toast://修改成功\\\";\\n}\\nlayout.push({\\n    title: \\\"log数\\\",\\n    url: $(Config.logNum, \\\"0<N<100\\\").input(setNum, \\\"logNum\\\", it => it > 0 && it < 100),\\n    desc: \\\"\\\" + Config.logNum,\\n    col_type: \\\"text_1\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"分批下载数(0不开启)\\\",\\n    url: $(\\\"\\\" + Config.threadNum, \\\"N>-1\\\").input(setNum, \\\"threadNum\\\", it => it > -1),\\n    desc: \\\"\\\" + Config.threadNum,\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        lineVisible: false,\\n    }\\n});\\n\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"<strong>小说阅读器设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"默认开启分页阅读\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((def_isPaginate) => {\\n        let Config = JSON.parse(readFile(\\\"config.json\\\") || \\\"{}\\\");\\n\\n        Config.def_isPaginate = def_isPaginate === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\";\\n\\n        saveFile(\\\"config.json\\\", JSON.stringify(Config));\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, Config.def_isPaginate),\\n    desc: Config.def_isPaginate === \\\"0\\\" ? \\\"不开启\\\" : \\\"开启\\\",\\n    col_type: \\\"text_1\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"每页最大章数\\\",\\n    url: $(Config.viewPageSize, \\\"30<N<500\\\").input(setNum, \\\"viewPageSize\\\", it => it > 30 && it < 500),\\n    desc: \\\"\\\" + Config.viewPageSize,\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"替换规则\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRecordHistory##noHistory##noRefresh#?settingType=replaceRule\\\",\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"<strong>其他设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    title: \\\"规则发布页\\\",\\n    url: \\\"hiker://page/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\",\\n    extra: {\\n        lver: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\",\\n        id: \\\"3559\\\"\\n    },\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"关于如何调用\\\",\\n    url: \\\"https://qun.qq.com/qqweb/qunpro/share?_wv=3&_wwv=128&inviteCode=1HFyBJ&from=246610&biz=ka\\\",\\n    desc: \\\"详细点击加入频道，频道里@LoyDgIk\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"恢复默认设置\\\",\\n    url: $(\\\"确认恢复默认设置？\\\").confirm(() => {\\n        deleteFile(\\\"config.json\\\");\\n        refreshPage(false);\\n        return \\\"toast://恢复完成\\\";\\n    }),\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"清理缓存\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRecordHistory##noHistory#?settingType=cache\\\",\\n    col_type: \\\"text_1\\\"\\n});\\n/*\\nlayout.push({\\n    title: \\\"清除小说分页记录\\\",\\n    url: $(\\\"确认清除小说分页记录？\\\").confirm(() => {\\n        deleteFile(\\\"novelFootprint.json\\\");\\n        return \\\"toast://清除完成\\\";\\n    }),\\n    col_type: \\\"text_1\\\"\\n});\\n*/\\nsetResult(layout);\"},{\"col_type\":\"text_1\",\"name\":\"#v.小说查看\",\"path\":\"NovelBrowser.view\",\"rule\":\"js:\\nif (getParam(\\\"hasParams\\\") === \\\"true\\\") {\\n    MY_PARAMS = {\\n        path: decodeURIComponent(getParam(\\\"path\\\")),\\n        name: decodeURIComponent(getParam(\\\"name\\\"))\\n    }\\n}\\nlet path = MY_PARAMS.path;\\nsetPageTitle(\\\"NV|\\\" + MY_PARAMS.name);\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nconst bookInfo = Object.assign({\\n    foot: 0,\\n    isReplace: true\\n}, JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\nlet id = \\\"#\\\" + new Date().getTime();\\nvar layout = [];\\nlet mode = getMyVar(\\\".mode\\\", \\\"0\\\");\\nlet mode2 = getMyVar(\\\".mode2\\\", Config.def_isPaginate);\\n\\nlet isReverse = getMyVar(\\\".isReverse\\\", \\\"0\\\");\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\".mode\\\");\\n    clearMyVar(\\\".mode2\\\");\\n    clearMyVar(\\\".isReverse\\\");\\n    clearMyVar(\\\".pageNum\\\");\\n}));\\n\\nfunction getTitle(title) {\\n    let titles = Tool.split(title, \\\"$\\\", 2);\\n    return titles[2] !== undefined ? titles[2].slice(0, titles[2].lastIndexOf(\\\".\\\")) : title;\\n}\\nlayout.push({\\n    title: \\\"删除整本\\\",\\n    url: $(\\\"确认删除整本小说？\\\").confirm((path) => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFlies(path)) {\\n            back();\\n            return \\\"toast://删除成功\\\";\\n        } else {\\n            return \\\"toast://删除失败\\\";\\n        }\\n    }, path),\\n    col_type: \\\"text_2\\\"\\n});\\n\\nlayout.push({\\n    title: [\\\"看小说\\\", \\\"删除章节\\\"][mode],\\n    url: $(\\\"#noLoading#\\\").lazyRule((mode) => {\\n        putMyVar(\\\".mode\\\", mode === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage(true);\\n        return \\\"hiker://empty\\\"\\n    }, mode),\\n    col_type: \\\"text_2\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"‘‘更多功能→’’\\\",\\n    url: \\\"hiker://empty\\\",\\n    col_type: \\\"scroll_button\\\"\\n});\\n\\nfunction txt(paths, isReplace) {\\n    showLoading(\\\"正在合并...\\\");\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n    const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n    const Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\n    let filelist = File.getFilePath(paths.path, \\\"file\\\", \\\".txt\\\");\\n    let listLength = filelist.length;\\n    if (listLength === 0) {\\n        hideLoading();\\n        return \\\"toast://空的章节\\\";\\n    }\\n    let bufilelist = [];\\n    for (let i = 0; i < listLength; i++) {\\n        let file = filelist[i];\\n        let fileInfo = Tool.split(file.name, \\\"$\\\", 2);\\n        bufilelist.push({\\n            name: fileInfo[2].slice(0, fileInfo[2].lastIndexOf(\\\".\\\")),\\n            path: \\\"file://\\\" + file.path,\\n            id: Number(fileInfo[0]) || 0\\n        });\\n    }\\n    bufilelist.sort((a, b) => a.id - b.id);\\n    let entirePath = paths.path.replace(Config.novelPath, Config.novelFullPath) + \\\".txt\\\";\\n    let entirePathto = isReplace ? entirePath + \\\".tmp\\\" : entirePath;\\n\\n    if (fileExist(\\\"file://\\\" + entirePath)) {\\n        toast(\\\"初始化文件\\\");\\n        if (!File.deleteFlies(entirePath)) {\\n            hideLoading();\\n            return \\\"toast://初始化失败\\\";\\n        } else {\\n            toast(\\\"初始化成功\\\");\\n        }\\n    }\\n\\n    for (let i = 0; i < listLength; i++) {\\n        let item = bufilelist[i];\\n        let content = request(item.path);\\n        File.fileWriteAppend(entirePathto, item.name + \\\"\\\\n　　\\\" + content.replace(/^\\\\s+|\\\\s+$/gm, \\\"\\\").split(/\\\\n+/).join(\\\"\\\\r　　\\\") + \\\"\\\\n\\\\n\\\");\\n    }\\n    if (isReplace) {\\n        let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n        ruleList = ruleList.filter(item => item.isEnabled);\\n        let len = ruleList.length;\\n        let replacePattern = [\\\"replace\\\", \\\"replaceAll\\\"];\\n        let flag = File.fileRule(entirePathto, entirePath, (javaString) => {\\n            for (let i = 0; i < len; i++) {\\n                let replaceRule = ruleList[i];\\n                let replace = replacePattern[0 + replaceRule.isRegex];\\n                javaString = javaString[replace](replaceRule.pattern, replaceRule.replacement);\\n            }\\n            return javaString.getBytes();\\n        });\\n        if (!flag) {\\n            hideLoading();\\n            return \\\"toast://合并失败\\\";\\n        }\\n\\n    }\\n    hideLoading();\\n    return \\\"toast://合并完成\\\";\\n}\\nlayout.push({\\n    title: \\\"合并小说\\\",\\n    url: $(\\\"确定合并?\\\\n会覆盖已有TXT\\\").confirm(txt, MY_PARAMS, bookInfo.isReplace),\\n    col_type: \\\"scroll_button\\\"\\n});\\nlayout.push({\\n    title: [\\\"☐分页\\\", \\\"☑分页\\\"][mode2],\\n    url: $(\\\"#noLoading#\\\").lazyRule((mode2) => {\\n        putMyVar(\\\".mode2\\\", mode2 === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage(true);\\n        return \\\"hiker://empty\\\";\\n    }, mode2),\\n    col_type: \\\"scroll_button\\\"\\n});\\nlayout.push({\\n    title: [\\\"☐净化\\\", \\\"☑净化\\\"][0 + bookInfo.isReplace],\\n    url: $(\\\"#noLoading#\\\").lazyRule((isReplace, path) => {\\n        const bookInfo = JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n        bookInfo.isReplace = !isReplace;\\n        writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, bookInfo.isReplace, path),\\n    col_type: \\\"scroll_button\\\"\\n});\\nlayout.push({\\n    title:'外部查看',\\n    url:$('#noLoading#').lazyRule((path,isReplace)=>{\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n    const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n    const Config = $.require(\\\"hiker://page/Config.json\\\");\\n    let entirePath = path.replace(Config.novelPath, Config.novelFullPath) + \\\".txt\\\";\\n    let entirePathto = isReplace ? entirePath + \\\".tmp\\\" : entirePath;\\n    //log(entirePathto);\\n    if (fileExist(\\\"file://\\\" + entirePath)) {\\n        toast(\\\"调用第三方应用打开文件\\\");\\n        return 'openFile://file://'+entirePath\\n    }else{\\n        return 'toast://本地暂无可供外部打开的txt文件，请先合并小说！'\\n    }\\n    },path,bookInfo.isReplace),\\n    col_type:'scroll_button'\\n});\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\n\\nlet mhlist = File.getFilePath(path, \\\"file\\\", \\\".txt\\\");\\nmhlist.sort((a, b) => {\\n    a = (a.name.match(/\\\\d+/) || [])[0] || 0;\\n    b = (b.name.match(/\\\\d+/) || [])[0] || 0;\\n    return a - b;\\n});\\nlet chapterList = [];\\nlet chapterCount = mhlist.length;\\n\\nif (mode2 === \\\"1\\\") {\\n    let mhlistChunk = Tool.chunk(mhlist, Config.viewPageSize);\\n    let viewPageCount = mhlistChunk.length;\\n    let defPage = (viewPageCount - 1 < bookInfo.foot ? 0 : bookInfo.foot) || 0;\\n    let pageNum = Number(getMyVar(\\\".pageNum\\\", \\\"\\\" + defPage));\\n    chapterList = mhlistChunk[pageNum] || [];\\n    layout.push({\\n        title: \\\"““””\\\" + \\\"章节 \\\".big() + (\\\"本页:\\\" + chapterList.length + \\\" 共有:\\\" + chapterCount + \\\"章 当前:\\\" + (pageNum + 1) + \\\"/\\\" + viewPageCount).small(),\\n        url: $(\\\"#noLoading#\\\").lazyRule((isReverse) => {\\n            putMyVar(\\\".isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage(true);\\n            return \\\"hiker://empty\\\"\\n        }, isReverse),\\n        col_type: \\\"text_1\\\"\\n    });\\n    layout.push({\\n        title: \\\"跳集\\\",\\n        url: $(chapterCount, \\\"输入跳转章节 1-\\\" + chapterCount).input((chapterCount, pageNum, viewPageSize, path) => {\\n            let inputNum = Number(input);\\n            if (Number.isNaN(inputNum) || inputNum < 0 || inputNum > chapterCount) {\\n                return \\\"toast://请输入正确范围内的数字\\\";\\n            }\\n            inputNum = Math.floor((inputNum + viewPageSize) / viewPageSize) - 1;\\n            if (pageNum === inputNum) return \\\"toast://正在当前页面\\\";\\n            putMyVar(\\\".pageNum\\\", \\\"\\\" + inputNum);\\n            const bookInfo = JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n            bookInfo.foot = inputNum;\\n            writeFile(\\\"file://\\\" + path, JSON.stringify(bookInfo));\\n            refreshPage(false);\\n        }, chapterCount, pageNum, Config.viewPageSize, path),\\n        col_type: \\\"text_5\\\"\\n    });\\n    layout.push({\\n        title: \\\"跳页\\\",\\n        url: $(pageNum + 1, \\\"跳转页数 1-\\\" + viewPageCount).input((viewPageCount, pageNum, path) => {\\n            let inputNum = Number(input) - 1;\\n            if (Number.isNaN(inputNum) || inputNum < 0 || inputNum > viewPageCount - 1) {\\n                return \\\"toast://请输入正确范围内的数字\\\";\\n            }\\n            if (pageNum === inputNum) return \\\"toast://正在当前页面\\\";\\n            putMyVar(\\\".pageNum\\\", \\\"\\\" + inputNum);\\n            const bookInfo = JSON.parse(request(path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n            bookInfo.foot = inputNum;\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            refreshPage(false);\\n        }, viewPageCount, pageNum, path),\\n        col_type: \\\"text_5\\\"\\n    });\\n    layout.push({\\n        title: \\\"上一页\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((pageNum, path) => {\\n            let inputNum = pageNum - 1;\\n            if (inputNum < 0) {\\n                return \\\"toast://已经是第一页了\\\";\\n            }\\n            putMyVar(\\\".pageNum\\\", \\\"\\\" + inputNum);\\n            const bookInfo = JSON.parse(request(path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n            bookInfo.foot = inputNum;\\n            log(bookInfo.foot);\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, pageNum, path),\\n        col_type: \\\"text_5\\\"\\n    });\\n    layout.push({\\n        title: \\\"下一页\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((viewPageCount, pageNum, path) => {\\n            let inputNum = pageNum + 1;\\n            if (inputNum > viewPageCount - 1) {\\n                return \\\"toast://已经是最后一页了\\\";\\n            }\\n            putMyVar(\\\".pageNum\\\", \\\"\\\" + inputNum);\\n            const bookInfo = JSON.parse(request(path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n            bookInfo.foot = inputNum;\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, viewPageCount, pageNum, path),\\n        col_type: \\\"text_5\\\"\\n    });\\n    layout.push({\\n        title: \\\"末页\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((viewPageCount, pageNum, path) => {\\n            let inputNum = viewPageCount - 1;\\n            if (pageNum === inputNum || inputNum === -1) {\\n                return \\\"toast://已经是最后一页了\\\";\\n            }\\n            putMyVar(\\\".pageNum\\\", \\\"\\\" + inputNum);\\n            const bookInfo = JSON.parse(request(path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n            bookInfo.foot = inputNum;\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, viewPageCount, pageNum, path),\\n        col_type: \\\"text_5\\\"\\n    });\\n} else {\\n    chapterList = mhlist;\\n    layout.push({\\n        title: \\\"““””\\\" + \\\"章节 \\\".big() + (\\\"共有:\\\" + chapterCount + \\\"章\\\").small(),\\n        url: $(\\\"#noLoading#\\\").lazyRule((isReverse) => {\\n            putMyVar(\\\".isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage(true);\\n            return \\\"hiker://empty\\\"\\n        }, isReverse),\\n        col_type: \\\"text_1\\\"\\n    });\\n}\\nlet array = [];\\nif (mode === \\\"0\\\") {\\n    for (let item of chapterList) {\\n        let name = getTitle(item.name);\\n        array.push({\\n            title: name,\\n            url: \\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\",\\n            extra: {\\n                path: item.path,\\n                title: name,\\n                isReplace: bookInfo.isReplace\\n            },\\n            col_type: Config.def_View_Style\\n        });\\n    }\\n} else {\\n    for (let item of chapterList) {\\n        let name = getTitle(item.name);\\n        array.push({\\n            title: name,\\n            url: $(\\\"确认删除[\\\" + name + \\\"]？\\\").confirm((path) => {\\n                const File = $.require(\\\"hiker://page/File.js\\\");\\n                if (File.deleteFlies(path)) {\\n                    refreshPage(true);\\n                    return \\\"toast://删除成功\\\";\\n                } else {\\n                    return \\\"toast://删除失败\\\";\\n                }\\n            }, item.path),\\n            col_type: Config.def_View_Style\\n        });\\n    }\\n}\\nif (isReverse === \\\"1\\\") {\\n    array.reverse();\\n}\\nlayout.push.apply(layout, array);\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.小说正文阅读\",\"path\":\"NovelMainBody\",\"rule\":\"js:\\nvar layout = [];\\nlet content = request(\\\"file://\\\" + MY_PARAMS.path);\\n//content = content.replace(/\\\\n|\\\\r/g, \\\"<br>\\\").replace(/(&nbsp;)+/g,\\\" \\\");\\nif (MY_PARAMS.isReplace) {\\n    let javaString = java.lang.String(content);\\n    let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n    let replacePattern = [\\\"replace\\\", \\\"replaceAll\\\"];\\n    for (let i = 0, len = ruleList.length; i < len; i++) {\\n        let replaceRule = ruleList[i];\\n        if (!replaceRule.isEnabled) continue;\\n        let replace = replacePattern[0 + replaceRule.isRegex];\\n        javaString = javaString[replace](replaceRule.pattern, replaceRule.replacement);\\n    }\\n    content = String(javaString);\\n}\\ncontent = \\\"　　\\\" + content.replace(/^\\\\s+|\\\\s+$/gm, \\\"\\\").split(/\\\\n+/).join(\\\"<br>　　\\\");\\n\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + MY_PARAMS.title + \\\"</strong>\\\").big(),\\n});\\n\\nlayout.push({\\n    title: content,\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: 18,\\n        click: true\\n    }\\n});\\nsetResult(layout);\"},{\"col_type\":\"text_1\",\"name\":\"#v.小说全集查看\",\"path\":\"NovelCollected.view\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nlet rulelDir = File.getFilePath(Config.novelFullPath, \\\"dir\\\");\\n\\nlet layout = [];\\n\\nfunction operation(path) {\\n    switch (input) {\\n        case \\\"分享\\\":\\n            return \\\"share://\\\" + path;\\n            break;\\n        case \\\"删除\\\":\\n            const File = $.require(\\\"hiker://page/File.js\\\");\\n            if (File.deleteFlies(path)) {\\n                refreshPage();\\n                return \\\"toast://删除成功\\\";\\n            } else {\\n                return \\\"toast://删除失败\\\";\\n            }\\n            break;\\n        case \\\"预览\\\":\\n            return \\\"editFile://file://\\\" + path;\\n        case \\\"外部查看\\\":\\n            return \\\"openFile://file://\\\" + path;\\n            break;\\n    }\\n}\\nfor (let rulePaths of rulelDir) {\\n    let novels = File.getFilePath(rulePaths.path, \\\"file\\\");\\n    for (let novel of novels) {\\n        layout.push({\\n            title: novel.name,\\n            url: $([\\\"分享\\\", \\\"删除\\\", \\\"预览\\\",\\\"外部查看\\\"], 1).select(operation, novel.path),\\n            desc: \\\"来源：\\\" + rulePaths.name,\\n            col_type: \\\"text_1\\\"\\n        });\\n    }\\n}\\nif (layout.length === 0) {\\n    layout.push({\\n        title: '<h1 style=\\\"text-align: center;\\\">啥都没有耶</h1>',\\n        col_type: \\\"rich_text\\\"\\n    });\\n}\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.更多设置\",\"path\":\"Setting/More.view\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nconst settingType = MY_PARAMS.settingType || getParam(\\\"settingType\\\");\\n\\nlet layout = [];\\n\\nswitch (settingType) {\\n    case \\\"cache\\\":\\n        setPageTitle(\\\"清除缓存|设置\\\");\\n        const knownList = new Map([\\n            [File.getName(Config.novelPath), \\\"#管理器#小说缓存目录[不建议清除]\\\"],\\n            [File.getName(Config.comicPath), \\\"#管理器#漫画缓存目录[不建议清除]\\\"],\\n            [File.getName(Config.novelFullPath), \\\"#管理器#小说合并目录[可以清除]\\\"],\\n            [\\\"dr章节缓存\\\", \\\"道长模板临时缓存[建议清除]\\\"]\\n        ]);\\n\\n        let cacheDir = File.getFilePath(Config.homePath, \\\"dir\\\");\\n\\n        function cleanCache(path) {\\n            const File = $.require(\\\"hiker://page/File.js\\\");\\n            if (File.deleteFlies(path)) {\\n                refreshPage(false);\\n                return \\\"toast://清除完成\\\";\\n            } else {\\n                return \\\"toast://清除失败\\\";\\n            }\\n        }\\n        for (let cache of cacheDir) {\\n            layout.push({\\n                title: cache.name,\\n                desc: \\\"大小：\\\" + File.getFileSize(cache.path) + \\\"\\\\n描述：\\\" + knownList.get(cache.name) || \\\"未知目录[风险未知]\\\",\\n                col_type: \\\"text_1\\\",\\n                url: $(\\\"确认清除 \\\" + cache.name + \\\" ?\\\").confirm(cleanCache, cache.path)\\n            });\\n        }\\n        layout.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n        layout.push({\\n            title: \\\"全部清除(\\\" + File.getFileSize(Config.homePath) + \\\")\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: $(\\\"确认清除全部缓存数据?\\\").confirm(cleanCache, Config.homePath)\\n        });\\n        break;\\n    case \\\"defaultPic\\\":\\n        setPageTitle(\\\"默认封面|设置\\\");\\n\\n        function setDefaultPic(url) {\\n            let Config = JSON.parse(readFile(\\\"config.json\\\") || \\\"{}\\\");\\n            Config.def_Pic = url;\\n            saveFile(\\\"config.json\\\", JSON.stringify(Config));\\n            back();\\n            return \\\"toast://修改成功\\\";\\n        }\\n        for (let i = 1; i <= 4; i++) {\\n            layout.push({\\n                title: \\\"图片\\\" + i,\\n                col_type: \\\"movie_3\\\",\\n                pic_url: \\\"hiker://images/home_pic\\\" + i,\\n                url: $(\\\"#noLoading#\\\").lazyRule(setDefaultPic, \\\"hiker://images/home_pic\\\" + i)\\n            });\\n        }\\n        break;\\n    case \\\"replaceRule\\\":\\n        setPageTitle(\\\"替换规则|设置\\\");\\n        let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n        let id = \\\"#\\\" + new Date().getTime();\\n\\n        layout.push({\\n            title: \\\"新建替换\\\",\\n            url: \\\"hiker://page/editReplaceRule.view#noRecordHistory##noHistory##noRefresh#?isNew=true\\\",\\n            col_type: \\\"text_3\\\"\\n        });\\n        layout.push({\\n            title: \\\"导出规则\\\",\\n            url: $(\\\"确认导出\\\" + ruleList.length + \\\"条规则？\\\\n({homePtah}/replaceRule.json)\\\").confirm((num) => {\\n                const Config = $.require(\\\"hiker://page/Config.json\\\");\\n                let savePta = Config.homePath + \\\"/replaceRule.json\\\";\\n                writeFile(savePta, readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n                log(\\\"\\\\n路径：\\\" + savePta + \\\"\\\\n导出规则 \\\" + num + \\\" 条\\\");\\n                return \\\"share://\\\" + savePta;\\n            }, ruleList.length),\\n            col_type: \\\"text_3\\\"\\n        });\\n        layout.push({\\n            title: \\\"导入规则\\\",\\n            url: $(\\\"\\\", \\\"输入规则文件路径(*.json)\\\", \\\"规则导入\\\").input(() => {\\n                input = input.startsWith(\\\"file://\\\") ? input : \\\"file://\\\" + input\\n                let ruleText = request(input);\\n                if (!ruleText) return \\\"toast://获取文件为空\\\";\\n                try {\\n                    let newRuleList = JSON.parse(ruleText);\\n                    let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n                    let newCount = 0,\\n                        updateCount = 0;\\n                    for (let i in newRuleList) {\\n                        let newRule = newRuleList[i];\\n                        let id = newRule.id;\\n                        newRule.id = id || new Date().getTime();\\n                        let idIndex = ruleList.findIndex(rule => rule.id === id);\\n                        if (idIndex > -1) {\\n                            updateCount++;\\n                            ruleList.splice(idIndex, 1, newRule);\\n                        } else {\\n                            newCount++;\\n                            ruleList.push(newRule);\\n                        }\\n                    }\\n                    saveFile(\\\"replaceRule.json\\\", JSON.stringify(ruleList));\\n                    refreshPage();\\n                    log(\\\"\\\\n路径：\\\" + input + \\\"\\\\n总规则数：\\\" + newRuleList.length + \\\"\\\\n更新规则 \\\" + updateCount + \\\" 条\\\\t新增规则 \\\" + newCount + \\\" 条\\\");\\n                    return \\\"toast://导入成功\\\";\\n                } catch (e) {\\n                    log(e.toString());\\n                    return \\\"toast://导入失败\\\";\\n                }\\n            }),\\n            col_type: \\\"text_3\\\"\\n        });\\n        layout.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n        for (let i = 0, len = ruleList.length; i < len; i++) {\\n            let replaceRule = ruleList[i];\\n            layout.push({\\n                title: (replaceRule.isEnabled ? \\\"●\\\" : \\\"○\\\") + replaceRule.name,\\n                col_type: \\\"text_1\\\",\\n                url: \\\"hiker://empty\\\",\\n                extra: {\\n                    id: id + i,\\n                    lineVisible: false\\n                }\\n            });\\n            layout.push({\\n                title: \\\"删除\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((id, index) => {\\n                    var ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n                    ruleList.splice(index, 1);\\n                    saveFile(\\\"replaceRule.json\\\", JSON.stringify(ruleList));\\n                    deleteItem(id + index);\\n                    deleteItem(id +\\\"#\\\" +index);\\n                    deleteItem(id +\\\"$\\\" +index);\\n                    deleteItem(id +\\\"@\\\" +index);\\n                    toast(\\\"删除成功\\\");\\n                    return \\\"hiker://empty\\\";\\n                }, id, i),\\n                extra:{\\n                    id: id+\\\"#\\\"+i\\n                },\\n                col_type: \\\"text_3\\\"\\n            });\\n            layout.push({\\n                title: \\\"编辑\\\",\\n                url: \\\"hiker://page/editReplaceRule.view#noRecordHistory##noHistory##noRefresh#?index=\\\" + i,\\n                col_type: \\\"text_3\\\",\\n                extra:{\\n                    id: id+\\\"$\\\"+i\\n                }\\n            });\\n            layout.push({\\n                title: \\\"开启/关闭\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((id, index, title) => {\\n                    var ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n                    let isEnabled = ruleList[index].isEnabled;\\n                    ruleList[index].isEnabled = !isEnabled;\\n                    updateItem({\\n                        extra: {\\n                            id: id + index,\\n                            lineVisible: false\\n                        },\\n                        title: (isEnabled ? \\\"○\\\" : \\\"●\\\") + title\\n                    });\\n                    saveFile(\\\"replaceRule.json\\\", JSON.stringify(ruleList));\\n                    return \\\"hiker://empty\\\";\\n                }, id, i, replaceRule.name),\\n                col_type: \\\"text_3\\\",\\n                extra:{\\n                    id: id+\\\"@\\\"+i\\n                }\\n            });\\n            layout.push({\\n                col_type: \\\"line\\\"\\n            });\\n        }\\n\\n        break;\\n}\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.编辑替换规则\",\"path\":\"editReplaceRule.view\",\"rule\":\"js:\\nconst isNew = MY_PARAMS.isNew || getParam(\\\"isNew\\\");\\nconst index = MY_PARAMS.index || Number(getParam(\\\"index\\\"));\\nlet layout = [];\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\".editReplaceRule.name\\\");\\n    clearMyVar(\\\".editReplaceRule.isRegex\\\");\\n    clearMyVar(\\\".editReplaceRule.pattern\\\");\\n    clearMyVar(\\\".editReplaceRule.replacement\\\");\\n    clearMyVar(\\\".editReplaceRule.first\\\");\\n    //clearMyVar(\\\".editReplaceRule.scope\\\");\\n}));\\nlet ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\nlet id = \\\"#\\\" + new Date().getTime();\\n//let replaceRule = isNew == \\\"true\\\"?{}:ruleList[index];\\nif (isNew == \\\"true\\\") {\\n    replaceRule = {\\n        id: new Date().getTime(),\\n        isEnabled: true,\\n        isRegex: false,\\n    }\\n} else {\\n    replaceRule = ruleList[index];\\n}\\n//首次初始化\\nif(getMyVar(\\\".editReplaceRule.first\\\",\\\"\\\")==\\\"\\\"){\\n    putMyVar(\\\".editReplaceRule.isRegex\\\", \\\"\\\" + replaceRule.isRegex);\\n    putMyVar(\\\".editReplaceRule.first\\\",\\\"1\\\");\\n}\\nlayout.push({\\n    title: \\\"拷贝\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let att = [\\\"name\\\", \\\"isRegex\\\", \\\"pattern\\\", \\\"replacement\\\"];\\n        let json = {};\\n        att.forEach(key => {\\n            let value = getMyVar(\\\".editReplaceRule.\\\" + key, \\\"\\\");\\n            if (key === \\\"isRegex\\\") {\\n                value = value === \\\"true\\\" ? true : false;\\n            }\\n            json[key] = value;\\n        });\\n        copy(JSON.stringify(json));\\n        return \\\"hiker://empty\\\";\\n    }),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    title: \\\"粘贴\\\",\\n    url: $(\\\"{{clipboard}}\\\").input(() => {\\n        try {\\n            let json = JSON.parse(input);\\n            if (Array.isArray(json) || json.pattern == undefined) return;\\n            let att = [\\\"name\\\", \\\"isRegex\\\", \\\"pattern\\\", \\\"replacement\\\"];\\n            att.forEach(key => {\\n                putMyVar(\\\".editReplaceRule.\\\" + key, String(json[key]));\\n            });\\n            refreshPage(false);\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换规则名称\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getMyVar(\\\".editReplaceRule.name\\\", replaceRule.name),\\n        onChange: 'putMyVar(\\\".editReplaceRule.name\\\",input);'\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换规则\\\",\\n    extra: {\\n        titleVisible: false,\\n        type: \\\"textarea\\\",\\n        height: -1,\\n        defaultValue: getMyVar(\\\".editReplaceRule.pattern\\\", replaceRule.pattern),\\n        onChange: 'putMyVar(\\\".editReplaceRule.pattern\\\", input);'\\n    }\\n});\\nlayout.push({\\n    title: \\\"是否使用正则表达式：\\\" + getMyVar(\\\".editReplaceRule.isRegex\\\"),\\n    url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n        let isRegex = getMyVar(\\\".editReplaceRule.isRegex\\\") === \\\"true\\\" ? false : true;\\n        updateItem({\\n            extra: {\\n                id: id\\n            },\\n            title: \\\"是否使用正则表达式：\\\" + isRegex\\n        });\\n        putMyVar(\\\".editReplaceRule.isRegex\\\", \\\"\\\" + isRegex);\\n        return \\\"hiker://empty\\\";\\n    }, id),\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        id: id\\n    }\\n});\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换为\\\",\\n    extra: {\\n        titleVisible: false,\\n        type: \\\"textarea\\\",\\n        height: -1,\\n        defaultValue: getMyVar(\\\".editReplaceRule.replacement\\\", replaceRule.replacement),\\n        onChange: 'putMyVar(\\\".editReplaceRule.replacement\\\",input);'\\n    }\\n});\\nlayout.push({\\n    title: \\\"保存\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((replaceRule, isNew, index) => {\\n        let pattern = getMyVar(\\\".editReplaceRule.pattern\\\", \\\"\\\");\\n        if (!pattern) {\\n            return \\\"toast://替换规则不能为空\\\";\\n        }\\n        Object.assign(replaceRule, {\\n            name: getMyVar(\\\".editReplaceRule.name\\\", \\\"\\\"),\\n            isRegex: getMyVar(\\\".editReplaceRule.isRegex\\\") === \\\"true\\\" ? true : false,\\n            pattern: pattern,\\n            replacement: getMyVar(\\\".editReplaceRule.replacement\\\", \\\"\\\")\\n        });\\n        let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n        if (isNew == \\\"true\\\") {\\n            ruleList.push(replaceRule);\\n        } else {\\n            ruleList.splice(index, 1, replaceRule);\\n        }\\n        saveFile(\\\"replaceRule.json\\\", JSON.stringify(ruleList));\\n        back();\\n        return \\\"toast://保存成功\\\";\\n    }, replaceRule, isNew, index),\\n    col_type: \\\"text_center_1\\\",\\n});\\n\\n/*\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换范围\\\",\\n    extra: {\\n        titleVisible: false,\\n        type: \\\"textarea\\\",\\n        height: -1,\\n        defaultValue: \\\"\\\",\\n        onChange: 'putMyVar(\\\".editReplaceRule.scope\\\",input);'\\n    }\\n});\\n\\n*/\\nsetResult(layout);\"}],\"params\":\"{\\\"chapterList\\\":[{\\\"title\\\":\\\"序章 信息素匹配度0%的绝对纯洁？！\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=0\\\"},{\\\"title\\\":\\\"1 优秀的你值得认识优秀的我\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=1\\\"},{\\\"title\\\":\\\"2 是他自己送上门的\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=2\\\"},{\\\"title\\\":\\\"3 要不要把校服脱掉？\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=3\\\"},{\\\"title\\\":\\\"4 0%的绝对安全\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=4\\\"},{\\\"title\\\":\\\"童年初见 娃娃仇的开端\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=5\\\"},{\\\"title\\\":\\\"5 校草的早有预谋\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=6\\\"},{\\\"title\\\":\\\"6 肖彦，你完了！（内含福利活动）\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=7\\\"},{\\\"title\\\":\\\"中秋番外 橘子兔兔终于对桃子兔兔下口了！\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=8\\\"},{\\\"title\\\":\\\"7 是水蜜桃味的青皮橘子\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=9\\\"},{\\\"title\\\":\\\"8 快来，我等你\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=10\\\"},{\\\"title\\\":\\\"表情包 表情包？拿来吧你\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=11\\\"},{\\\"title\\\":\\\"9 绝对纯洁的校友\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=12\\\"},{\\\"title\\\":\\\"10 我俩都是清白的！绝不是耍流氓\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=13\\\"},{\\\"title\\\":\\\"11 是橘子味的水蜜桃\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=14\\\"},{\\\"title\\\":\\\"12 大不了让你咬回来\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=15\\\"},{\\\"title\\\":\\\"万圣节 不给糖果就捣乱\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=16\\\"},{\\\"title\\\":\\\"13 想好怎么贿赂我了吗，洛知予\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=17\\\"},{\\\"title\\\":\\\"14 是0301肖彦啊\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=18\\\"},{\\\"title\\\":\\\"15 要记得肖彦对你的好\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=19\\\"},{\\\"title\\\":\\\"16 你是不是小流氓\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=20\\\"},{\\\"title\\\":\\\"17 如何正确诱捕桃子\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=21\\\"},{\\\"title\\\":\\\"18 到底谁是肖彦？\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=22\\\"},{\\\"title\\\":\\\"19 肖彦怎么可能是渣A？\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=23\\\"},{\\\"title\\\":\\\"圣诞节 桃桃圣诞礼物派发中\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=24\\\"},{\\\"title\\\":\\\"20 狠狠的揍他，绝不留情\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=25\\\"},{\\\"title\\\":\\\"21 一天来两回，我是有多爱他\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=26\\\"},{\\\"title\\\":\\\"22 不欺负你了，只对你好\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=27\\\"},{\\\"title\\\":\\\"23 那你难道，要我抱你？\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=28\\\"},{\\\"title\\\":\\\"视频话 第2卷预告\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=29\\\"},{\\\"title\\\":\\\"24 肖彦那个王八蛋！（内含福利活动）\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=30\\\"},{\\\"title\\\":\\\"25 那个谁，你帮我一下呗\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=31\\\"},{\\\"title\\\":\\\"新年番外 没想到你是这样的彦哥？！\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=32\\\"},{\\\"title\\\":\\\"表情包 表情包？拿来吧你2+小假条\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=33\\\"},{\\\"title\\\":\\\"26 洛知了，我赖上你了\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=34\\\"},{\\\"title\\\":\\\"27 彦哥的内心，跌宕起伏\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=35\\\"},{\\\"title\\\":\\\"28 他的信息素……好甜\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=36\\\"},{\\\"title\\\":\\\"29 好痛哦，你没有良心\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=37\\\"},{\\\"title\\\":\\\"30 知了，出来玩啊~\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=38\\\"},{\\\"title\\\":\\\"31 要不，你别回家了\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=39\\\"},{\\\"title\\\":\\\"32 洛知了，三天不打上房揭瓦~\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=40\\\"},{\\\"title\\\":\\\"33 让我闻闻你的信息素呗\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=41\\\"},{\\\"title\\\":\\\"cp头像+明天见 cp头像用起来呀\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=42\\\"},{\\\"title\\\":\\\"34 他不是渣A，我也不纯情\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=43\\\"},{\\\"title\\\":\\\"35 彦哥，你再过来一点\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=44\\\"},{\\\"title\\\":\\\"小互动+中午见 发挥想象得时候到了\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=45\\\"},{\\\"title\\\":\\\"36 我真的不是小流氓\\\",\\\"url\\\":\\\"https://cn.baozimh.com/user/page_direct?comic_id=xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue&section_slot=0&chapter_slot=46\\\"}],\\\"defaultView\\\":\\\"1\\\",\\\"info\\\":{\\\"bookName\\\":\\\"信息素说我们不可能\\\",\\\"bookTopPic\\\":\\\"https://static-tw.baozimh.com/cover/xinxisushuowomenbukeneng-zuozheersanjiulugongzuoshiyuanzhumaoqiuqiuchangpeiwenxue.jpg\\\",\\\"parseCode\\\":\\\"(\\\\n() => {\\\\n    var htmls = request(input);\\\\n    var list = parseDomForArray(htmls, \\\\\\\"body&&img\\\\\\\");\\\\n    var pics = [];\\\\n    for (i in list) {\\\\n        pics.push(parseDomForHtml(list[i], \\\\\\\"img&&src\\\\\\\"));\\\\n    }\\\\n    return pics;\\\\n}\\\\n)()\\\",\\\"ruleName\\\":\\\"包子漫画\\\"}}\",\"saved\":false,\"title\":\"本地资源管理\",\"version\":0,\"url\":\"hiker://page/download.view#noHistory##noRecordHistory##noRefresh#?rule=本地资源管理\",\"col_type\":\"text_2\",\"find_rule\":\"js:\\nconst viewConfig = Object.assign({\\n    chapterList: [],\\n    info: {},\\n    defaultView: \\\"0\\\"\\n}, MY_PARAMS);\\nviewConfig.info = Object.assign({\\n    ruleName: \\\"\\\",\\n    bookName: \\\"\\\",\\n    bookTopPic: \\\"\\\",\\n    parseCode: \\\"\\\",\\n    type: \\\"comic\\\",\\n}, viewConfig.info);\\nlet {\\n    chapterList,\\n    info,\\n    defaultView\\n} = viewConfig;\\nsetPageTitle(\\\"选择器|\\\" + info.bookName)\\n\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nconst def_DoVi_Style = Config.def_DoVi_Style;\\nconst MY_ID = info.ruleName + \\\"//\\\" + info.bookName;\\n\\n\\nlet isStart = getMyVar(MY_ID + \\\":isStart\\\");\\nlet viewMode = getMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\nlet isReverse = getMyVar(MY_ID + \\\":isReverse\\\", \\\"0\\\");\\nlet tagFilter = getMyVar(MY_ID + \\\":tagFilter\\\", Config.def_DoVi_Type);\\n\\naddListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n    clearMyVar(MY_ID + \\\":loadingTeam\\\");\\n    clearMyVar(MY_ID + \\\":viewMode\\\");\\n    clearMyVar(MY_ID + \\\":completed\\\");\\n    clearMyVar(MY_ID + \\\":batchTeam\\\");\\n    clearMyVar(MY_ID + \\\":tagFilter\\\");\\n    clearMyVar(MY_ID + \\\":pageNum\\\");\\n}, MY_ID));\\n\\nlet layout = [];\\n\\nif (isStart === \\\"1\\\") {\\n    putMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\n    viewMode = \\\"1\\\";\\n}\\n\\nlet backupChapterList = chapterList;\\nif (typeof chapterList === \\\"string\\\") {\\n    chapterList = JSON.parse(request(\\\"file://\\\" + chapterList) || \\\"[]\\\");\\n}\\nlet chapterAll = chapterList;\\nchapterList = chapterList.map((item, CID) => {\\n    item.CID = CID;\\n    return item;\\n});\\nlet pageNum = Number(getMyVar(MY_ID + \\\":pageNum\\\", \\\"1\\\"));\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\nchapterList = chapterChunk[pageNum] || [];\\n\\nfunction setType() {\\n    let set = (tag, put) => {\\n        putMyVar(put, tag);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    };\\n    layout.push({\\n        title: 0 == pageNum ? \\\"““””\\\" + (\\\"全部(\\\" + chapterAll.length + \\\")\\\").fontcolor(\\\"#23AD6F\\\") : \\\"全部(\\\" + chapterAll.length + \\\")\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, 0, MY_ID + \\\":pageNum\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    for (let i = 1; i < chapterChunk.length; i++) {\\n        let tagText = (i - 1) * Config.viewPageSize + \\\"-\\\" + ((i - 1) * Config.viewPageSize + chapterChunk[i].length);\\n        layout.push({\\n            title: i == pageNum ? \\\"““””\\\" + tagText.fontcolor(\\\"#23AD6F\\\") : tagText,\\n            url: $(\\\"#noLoading#\\\").lazyRule(set, i, MY_ID + \\\":pageNum\\\"),\\n            col_type: \\\"scroll_button\\\"\\n        });\\n    }\\n    layout.push({\\n        col_type: \\\"blank_block\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"0\\\" ? \\\"““””\\\" + \\\"全部\\\".fontcolor(\\\"#23AD6F\\\") : \\\"全部\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"0\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"1\\\" ? \\\"““””\\\" + \\\"未下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"未下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"1\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"2\\\" ? \\\"““””\\\" + \\\"已下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"已下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"2\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n}\\nlet chapterTeam = [];\\nlet record = [];\\nif (info.type === \\\"comic\\\") {\\n    let lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        let filelist = File.getFilePath(input);\\n        let piclist = filelist.map((item, i) => \\\"file://\\\" + input + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n        return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n    });\\n\\n    function comFun(i, item) {\\n        let rootPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title;\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: rootPath + lazy,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"dir\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2]);\\n        }\\n    });\\n} else {\\n    function comFun(i, item) {\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n                path: Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title + \\\".txt\\\",\\n                title: item.title\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"file\\\", \\\".txt\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\".\\\")));\\n        }\\n    });\\n}\\n\\nfunction clickDownload(item, info, MY_ID, i) {\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = loadingTeam.indexOf(i);\\n    if (ElementIndex > -1) return \\\"toast://正在下载\\\";\\n\\n    loadingTeam.push(i);\\n    putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    updateItem({\\n        title: \\\"‘‘\\\" + item.title + \\\"’’\\\",\\n        extra: {\\n            id: MY_ID + \\\"#\\\" + i\\n        }\\n    });\\n    let result = \\\"toast://下载失败\\\";\\n    try {\\n        toast(\\\"开始下载:\\\" + item.title);\\n        let download = $.require(\\\"hiker://page/Download.exe.js\\\");\\n        result = download(item, info, MY_ID, i);\\n        updateItem({\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"toast://已下载\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n    } catch (e) {\\n        updateItem({\\n            title: item.title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        log(e.toString());\\n    } finally {\\n        loadingTeam.splice(ElementIndex, 1);\\n        putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    }\\n    return result;\\n}\\n\\nfunction singleView() {\\n    layout.push({\\n        title: \\\"反转列表\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((isReverse, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, isReverse, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    layout.push({\\n        title: \\\"批量下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            if (loadingTeam.length > 0) return \\\"toast://还有任务没有完成\\\";\\n            if (getAppVersion() < 2594) return \\\"toast://未开放\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"1\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n\\n        }, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: loadingTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n}\\n\\nfunction clickChoose(title, MY_ID, i) {\\n    let isStart = getMyVar(MY_ID + \\\":isStart\\\");\\n    if (isStart === \\\"1\\\") return \\\"toast://正在下载...\\\";\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = batchTeam.indexOf(i);\\n    if (ElementIndex > -1) {\\n        updateItem({\\n            title: title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.splice(ElementIndex, 1);\\n    } else {\\n        updateItem({\\n            title: \\\"‘‘\\\" + title + \\\"’’\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.push(i);\\n    }\\n    putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n    return \\\"hiker://empty\\\";\\n}\\n\\nfunction batchView() {\\n    layout.push({\\n        title: \\\"单选下载\\\",\\n        pic_url: \\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在批量下载\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"0\\\");\\n            clearMyVar(MY_ID + \\\":batchTeam\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\n    let end = start + chapterList.length;\\n    layout.push({\\n        title: \\\"选择全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = Tool.range(start, end);\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\":completed\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"取消全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = new Set(Tool.range(start, end));\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"确认选中\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\", \\\"-1\\\") !== \\\"-1\\\") {\\n                return \\\"toast://正在下载...\\\";\\n            }\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            return batchTeam.length === 0 ? \\\"toast://你还什么都没有选\\\" : \\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\";\\n        }, MY_ID),\\n        extra: {\\n            newWindow: true,\\n            windowId: MY_ID + \\\"//批量下载\\\",\\n            MY_ID: MY_ID,\\n            chapterList: backupChapterList,\\n            info: info\\n        },\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let completed = [];\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            completed.push(item.CID);\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: batchTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n    putMyVar(MY_ID + \\\":completed\\\", JSON.stringify(completed));\\n}\\nswitch (viewMode) {\\n    case \\\"0\\\":\\n        singleView();\\n        break;\\n    case \\\"1\\\":\\n        batchView();\\n        break;\\n}\\nif (isReverse === \\\"1\\\") {\\n    chapterTeam.reverse();\\n}\\nlayout.push.apply(layout, chapterTeam);\\nsetResult(layout);\",\"group\":\"①推荐\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#f.File工具\\\",\\\"path\\\":\\\"File.js\\\",\\\"rule\\\":\\\"const File = java.io.File;\\\\nconst {\\\\n    Files,\\\\n    Paths,\\\\n    StandardCopyOption,\\\\n    StandardOpenOption\\\\n} = java.nio.file;\\\\nconst javaString = java.lang.String;\\\\nlet javaScope = new JavaImporter(java.io, java.lang, java.lang.reflect, java.util.Vector);\\\\n\\\\nfunction deleteFlies(fileName) {\\\\n    let file = new File(fileName);\\\\n    if (!file.exists()) {\\\\n        //log(\\\\\\\"删除文件失败：\\\\\\\" + fileName + \\\\\\\"文件不存在\\\\\\\");\\\\n        return false;\\\\n    } else {\\\\n        if (file.isFile()) {\\\\n            return deleteFile(fileName);\\\\n        } else {\\\\n            return deleteDirectory(fileName);\\\\n        }\\\\n\\\\n    }\\\\n\\\\n}\\\\n/**\\\\n * 删除单个文件\\\\n * \\\\n * @param fileName\\\\n *            被删除文件的文件名\\\\n * @return 单个文件删除成功返回true,否则返回false\\\\n */\\\\nfunction deleteFile(fileName) {\\\\n    let file = new File(fileName);\\\\n    if (file.isFile() && file.exists()) {\\\\n        file.delete();\\\\n        //log(\\\\\\\"删除单个文件\\\\\\\" + fileName + \\\\\\\"成功！\\\\\\\");\\\\n        return true;\\\\n    } else {\\\\n        //log(\\\\\\\"删除单个文件\\\\\\\" + fileName + \\\\\\\"失败！\\\\\\\");\\\\n        return false;\\\\n    }\\\\n\\\\n}\\\\n/**\\\\n * 删除目录（文件夹）以及目录下的文件\\\\n * \\\\n * @param dir\\\\n *            被删除目录的文件路径\\\\n * @return 目录删除成功返回true,否则返回false\\\\n */\\\\nfunction deleteDirectory(dir) {\\\\n    // 如果dir不以文件分隔符结尾，自动添加文件分隔符\\\\n    if (!dir.endsWith(File.separator)) {\\\\n        dir = dir + File.separator;\\\\n    }\\\\n    let dirFile = new File(dir);\\\\n    // 如果dir对应的文件不存在，或者不是一个目录，则退出\\\\n    if (!dirFile.exists() || !dirFile.isDirectory()) {\\\\n        //log(\\\\\\\"删除目录失败\\\\\\\" + dir + \\\\\\\"目录不存在！\\\\\\\");\\\\n        return false;\\\\n    }\\\\n    let flag = true;\\\\n    // 删除文件夹下的所有文件(包括子目录)\\\\n    let files = dirFile.listFiles();\\\\n    for (let i = 0; i < files.length; i++) {\\\\n        // 删除子文件\\\\n        if (files[i].isFile()) {\\\\n            flag = deleteFile(files[i].getAbsolutePath());\\\\n            if (!flag) {\\\\n                break;\\\\n            }\\\\n        } else { // 删除子目录\\\\n            flag = deleteDirectory(files[i].getAbsolutePath());\\\\n            if (!flag) {\\\\n                break;\\\\n            }\\\\n        }\\\\n    }\\\\n    if (!flag) {\\\\n        //log(\\\\\\\"删除目录失败\\\\\\\");\\\\n        return false;\\\\n    }\\\\n    // 删除当前目录\\\\n    if (dirFile.delete()) {\\\\n        //log(\\\\\\\"删除目录\\\\\\\" + dir + \\\\\\\"成功！\\\\\\\");\\\\n        return true;\\\\n    } else {\\\\n        //log(\\\\\\\"删除目录\\\\\\\" + dir + \\\\\\\"失败！\\\\\\\");\\\\n        return false;\\\\n    }\\\\n}\\\\n\\\\nfunction getFileTime(path) {\\\\n    let file = new File(path);\\\\n    let lastModified = file.lastModified();\\\\n    let date = new Date(lastModified);\\\\n    return date.getTime();\\\\n}\\\\n\\\\nfunction getName(path) {\\\\n    return new File(path).getName() + \\\\\\\"\\\\\\\";\\\\n}\\\\n\\\\nfunction getFilePath(path, type, expand) {\\\\n    type = type || \\\\\\\"file\\\\\\\";\\\\n    if (![\\\\\\\"file\\\\\\\", \\\\\\\"dir\\\\\\\"].includes(type)) throw new Error(\\\\\\\"类型错误\\\\\\\");\\\\n    let fileType = type === \\\\\\\"file\\\\\\\" ? \\\\\\\"isFile\\\\\\\" : \\\\\\\"isDirectory\\\\\\\";\\\\n    let file = new File(path);\\\\n    let array = file.listFiles() || [];\\\\n    let pathList = [];\\\\n    for (let i = 0; i < array.length; i++) {\\\\n        if (array[i][fileType]()) {\\\\n            pathList.push({\\\\n                name: array[i].getName() + \\\\\\\"\\\\\\\",\\\\n                path: array[i].getPath() + \\\\\\\"\\\\\\\"\\\\n            });\\\\n        }\\\\n    }\\\\n    if (expand) {\\\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\\\n    }\\\\n    return pathList;\\\\n}\\\\n\\\\nfunction renameFile(fromPath, name) {\\\\n    let fromFile = new File(fromPath);\\\\n    let toFile = new File(fromFile.getParent() + \\\\\\\"/\\\\\\\" + name);\\\\n    try {\\\\n        if (!fromFile.exists()) {\\\\n            return false;\\\\n        }\\\\n        if (toFile.exists()) {\\\\n            if (!deleteFlies(toPath)) {\\\\n                return false;\\\\n            }\\\\n        }\\\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\\\n        return true;\\\\n    } catch (e) {\\\\n        log(e.toString());\\\\n        return false;\\\\n    }\\\\n}\\\\n\\\\nfunction moveFiles(fromPath, toPath) {\\\\n    let fromFile = new File(fromPath);\\\\n    let toFile = new File(toPath);\\\\n    try {\\\\n        if (!fromFile.exists()) {\\\\n            return false;\\\\n        }\\\\n        if (toFile.exists()) {\\\\n            if (!deleteFlies(toPath)) {\\\\n                return false;\\\\n            }\\\\n        }\\\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\\\n        return true;\\\\n    } catch (e) {\\\\n        log(e.toString());\\\\n        return false;\\\\n    }\\\\n}\\\\n\\\\nfunction fileWrite(path, content) {\\\\n    writeFile(\\\\\\\"file://\\\\\\\" + path, content)\\\\n}\\\\n\\\\nfunction fileWriteAppend(path, content) {\\\\n    let file = new File(path);\\\\n    let paths = file.toPath();\\\\n    if (file.exists()) {\\\\n        Files.write(paths, new javaString(content).getBytes(), StandardOpenOption.APPEND);\\\\n    } else {\\\\n        writeFile(\\\\\\\"file://\\\\\\\" + path, content);\\\\n    }\\\\n}\\\\n\\\\nfunction getTotalSizeOfFilesInDir(file) {\\\\n    if (file.isFile()) {\\\\n        return file.length();\\\\n    }\\\\n    let children = file.listFiles();\\\\n    let total = 0;\\\\n    if (children != null) {\\\\n        for (let child of children) {\\\\n            total += getTotalSizeOfFilesInDir(child);\\\\n        }\\\\n    }\\\\n    return total;\\\\n}\\\\n\\\\nfunction getFileSize(filePath) {\\\\n    //Byte\\\\n    let size = getTotalSizeOfFilesInDir(new File(filePath));\\\\n    if (size < 0) {\\\\n        return null;\\\\n    }\\\\n    let unitForm = [\\\\\\\"Byte\\\\\\\", \\\\\\\"KB\\\\\\\", \\\\\\\"MB\\\\\\\", \\\\\\\"GB\\\\\\\", \\\\\\\"TB\\\\\\\"];\\\\n    for (let i = 0, len = unitForm.length; i < len; i++) {\\\\n        if (size > 1024) {\\\\n            size /= 1024;\\\\n            continue;\\\\n        } else {\\\\n            return Math.ceil(size) + unitForm[i];\\\\n        }\\\\n    }\\\\n    return \\\\\\\"ERROR:数值过大\\\\\\\";\\\\n}\\\\n//完整合并\\\\n/*\\\\nfunction fileCombine(filesInput, fileOut, extension, intercept) {\\\\n    with(javaScope) {\\\\n        const TMP_BUFFER_SIZE = 0x30000;\\\\n        const BUFFER_SIZE = 0x300000;\\\\n        //合并临时文件\\\\n        let inputFile = new File(filesInput);\\\\n        let tmpFile = new File(fileOut + \\\\\\\".tmp\\\\\\\");\\\\n        let tos = new BufferedOutputStream(new FileOutputStream(tmpFile));\\\\n        let inputFiles = inputFile.listFiles();\\\\n        let tbys = Array.newInstance(Byte.TYPE, TMP_BUFFER_SIZE);\\\\n        for (let file of inputFiles) {\\\\n            if (file.getName().endsWith(extension)) {\\\\n                let is = new FileInputStream(file);\\\\n                let len = 0;\\\\n                while ((len = is.read(tbys)) != -1) {\\\\n                    tos.write(tbys, 0, len);\\\\n                }\\\\n                is.close();\\\\n            }\\\\n        }\\\\n        tos.close();\\\\n        //规则替换规则;\\\\n        let outFile = new File(fileOut);\\\\n        if (typeof intercept === \\\\\\\"function\\\\\\\") {\\\\n            let tis = new FileInputStream(tmpFile);\\\\n            let os = new BufferedOutputStream(new FileOutputStream(outFile));\\\\n            let len = 0;\\\\n            let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\\\n            while ((len = tis.read(bys)) != -1) {\\\\n                let nbys = intercept(new String(bys,0,len));\\\\n                os.write(nbys, 0, nbys.length);\\\\n            }\\\\n            tmpFile.delete();\\\\n            tis.close();\\\\n            os.close();\\\\n        } else {\\\\n            if (outFile.exists()) {\\\\n                outFile.delete();\\\\n            }\\\\n            tmpFile.renameTo(outFile);\\\\n        }\\\\n    }\\\\n}*/\\\\n//残\\\\nfunction fileRule(filesInput, fileOut, intercept) {\\\\n    with(javaScope) {\\\\n        const BUFFER_SIZE = 0x300000;\\\\n        let tmpFile = new File(filesInput);\\\\n        if(!(tmpFile.exists()&&tmpFile.isFile())){\\\\n            return false;\\\\n        }\\\\n        let outFile = new File(fileOut);\\\\n\\\\n        let tis = new FileInputStream(tmpFile);\\\\n        let os = new BufferedOutputStream(new FileOutputStream(outFile));\\\\n        let len = 0;\\\\n        let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\\\n        while ((len = tis.read(bys)) != -1) {\\\\n            let nbys = intercept(new String(bys,0,len));\\\\n            os.write(nbys, 0, nbys.length);\\\\n        }\\\\n        tmpFile.delete();\\\\n        tis.close();\\\\n        os.close();\\\\n        return true;\\\\n    }\\\\n}\\\\n\\\\n$.exports = {\\\\n    getFileTime: (path) => getFileTime(path),\\\\n    getFilePath: (path, type, expand) => getFilePath(path, type, expand),\\\\n    deleteFlies: (path) => deleteFlies(path),\\\\n    renameFile: (path, name) => renameFile(path, name),\\\\n    moveFiles: (fromPath, toPath) => moveFiles(fromPath, toPath),\\\\n    fileWrite: (path, content) => fileWrite(path, content),\\\\n    fileWriteAppend: (path, content) => fileWriteAppend(path, content),\\\\n    getName: (path) => getName(path),\\\\n    getFileSize: (filePath) => getFileSize(filePath),\\\\n    fileRule: (filesInput, fileOut, intercept) => fileRule(filesInput, fileOut, intercept)\\\\n}\\\"},{\\\"col_type\\\":\\\"text_2\\\",\\\"name\\\":\\\"#v.下载列表-普通下载\\\",\\\"path\\\":\\\"download.view\\\",\\\"rule\\\":\\\"js:\\\\nconst viewConfig = Object.assign({\\\\n    chapterList: [],\\\\n    info: {},\\\\n    defaultView: \\\\\\\"0\\\\\\\"\\\\n}, MY_PARAMS);\\\\nviewConfig.info = Object.assign({\\\\n    ruleName: \\\\\\\"\\\\\\\",\\\\n    bookName: \\\\\\\"\\\\\\\",\\\\n    bookTopPic: \\\\\\\"\\\\\\\",\\\\n    parseCode: \\\\\\\"\\\\\\\",\\\\n    type: \\\\\\\"comic\\\\\\\",\\\\n}, viewConfig.info);\\\\nlet {\\\\n    chapterList,\\\\n    info,\\\\n    defaultView\\\\n} = viewConfig;\\\\nsetPageTitle(\\\\\\\"选择器|\\\\\\\" + info.bookName)\\\\n\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nconst def_DoVi_Style = Config.def_DoVi_Style;\\\\nconst MY_ID = info.ruleName + \\\\\\\"//\\\\\\\" + info.bookName;\\\\n\\\\n\\\\nlet isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\nlet viewMode = getMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", defaultView);\\\\nlet isReverse = getMyVar(MY_ID + \\\\\\\":isReverse\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet tagFilter = getMyVar(MY_ID + \\\\\\\":tagFilter\\\\\\\", Config.def_DoVi_Type);\\\\n\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString((MY_ID) => {\\\\n    clearMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":completed\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":tagFilter\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":pageNum\\\\\\\");\\\\n}, MY_ID));\\\\n\\\\nlet layout = [];\\\\n\\\\nif (isStart === \\\\\\\"1\\\\\\\") {\\\\n    putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", defaultView);\\\\n    viewMode = \\\\\\\"1\\\\\\\";\\\\n}\\\\n\\\\nlet backupChapterList = chapterList;\\\\nif (typeof chapterList === \\\\\\\"string\\\\\\\") {\\\\n    chapterList = JSON.parse(request(\\\\\\\"file://\\\\\\\" + chapterList) || \\\\\\\"[]\\\\\\\");\\\\n}\\\\nlet chapterAll = chapterList;\\\\nchapterList = chapterList.map((item, CID) => {\\\\n    item.CID = CID;\\\\n    return item;\\\\n});\\\\nlet pageNum = Number(getMyVar(MY_ID + \\\\\\\":pageNum\\\\\\\", \\\\\\\"1\\\\\\\"));\\\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\\\nchapterList = chapterChunk[pageNum] || [];\\\\n\\\\nfunction setType() {\\\\n    let set = (tag, put) => {\\\\n        putMyVar(put, tag);\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    };\\\\n    layout.push({\\\\n        title: 0 == pageNum ? \\\\\\\"““””\\\\\\\" + (\\\\\\\"全部(\\\\\\\" + chapterAll.length + \\\\\\\")\\\\\\\").fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"全部(\\\\\\\" + chapterAll.length + \\\\\\\")\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, 0, MY_ID + \\\\\\\":pageNum\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n    for (let i = 1; i < chapterChunk.length; i++) {\\\\n        let tagText = (i - 1) * Config.viewPageSize + \\\\\\\"-\\\\\\\" + ((i - 1) * Config.viewPageSize + chapterChunk[i].length);\\\\n        layout.push({\\\\n            title: i == pageNum ? \\\\\\\"““””\\\\\\\" + tagText.fontcolor(\\\\\\\"#23AD6F\\\\\\\") : tagText,\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, i, MY_ID + \\\\\\\":pageNum\\\\\\\"),\\\\n            col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n        });\\\\n    }\\\\n    layout.push({\\\\n        col_type: \\\\\\\"blank_block\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: tagFilter === \\\\\\\"0\\\\\\\" ? \\\\\\\"““””\\\\\\\" + \\\\\\\"全部\\\\\\\".fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"全部\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, \\\\\\\"0\\\\\\\", MY_ID + \\\\\\\":tagFilter\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: tagFilter === \\\\\\\"1\\\\\\\" ? \\\\\\\"““””\\\\\\\" + \\\\\\\"未下载\\\\\\\".fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"未下载\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, \\\\\\\"1\\\\\\\", MY_ID + \\\\\\\":tagFilter\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: tagFilter === \\\\\\\"2\\\\\\\" ? \\\\\\\"““””\\\\\\\" + \\\\\\\"已下载\\\\\\\".fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"已下载\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, \\\\\\\"2\\\\\\\", MY_ID + \\\\\\\":tagFilter\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n}\\\\nlet chapterTeam = [];\\\\nlet record = [];\\\\nif (info.type === \\\\\\\"comic\\\\\\\") {\\\\n    let lazy = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        let filelist = File.getFilePath(input);\\\\n        let piclist = filelist.map((item, i) => \\\\\\\"file://\\\\\\\" + input + \\\\\\\"/\\\\\\\" + (i + 1) + \\\\\\\".jpg\\\\\\\");\\\\n        return \\\\\\\"pics://\\\\\\\" + piclist.join(\\\\\\\"&&\\\\\\\");\\\\n    });\\\\n\\\\n    function comFun(i, item) {\\\\n        let rootPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\" + i + \\\\\\\"$A$\\\\\\\" + item.title;\\\\n        return {\\\\n            title: \\\\\\\"““\\\\\\\" + item.title + \\\\\\\"””\\\\\\\",\\\\n            url: rootPath + lazy,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i,\\\\n            },\\\\n            col_type: def_DoVi_Style\\\\n        }\\\\n    }\\\\n    File.getFilePath(Config[info.type + \\\\\\\"Path\\\\\\\"] + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName, \\\\\\\"dir\\\\\\\").forEach((file) => {\\\\n        let att = Tool.split(file.name, \\\\\\\"$\\\\\\\", 2);\\\\n        if (att.length === 3 && att[1] === (\\\\\\\"A\\\\\\\")) {\\\\n            record.push(att[2]);\\\\n        }\\\\n    });\\\\n} else {\\\\n    function comFun(i, item) {\\\\n        return {\\\\n            title: \\\\\\\"““\\\\\\\" + item.title + \\\\\\\"””\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i,\\\\n                path: Config.novelPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\" + i + \\\\\\\"$A$\\\\\\\" + item.title + \\\\\\\".txt\\\\\\\",\\\\n                title: item.title\\\\n            },\\\\n            col_type: def_DoVi_Style\\\\n        }\\\\n    }\\\\n    File.getFilePath(Config[info.type + \\\\\\\"Path\\\\\\\"] + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName, \\\\\\\"file\\\\\\\", \\\\\\\".txt\\\\\\\").forEach((file) => {\\\\n        let att = Tool.split(file.name, \\\\\\\"$\\\\\\\", 2);\\\\n        if (att.length === 3 && att[1] === (\\\\\\\"A\\\\\\\")) {\\\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\\\\\".\\\\\\\")));\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nfunction clickDownload(item, info, MY_ID, i) {\\\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let ElementIndex = loadingTeam.indexOf(i);\\\\n    if (ElementIndex > -1) return \\\\\\\"toast://正在下载\\\\\\\";\\\\n\\\\n    loadingTeam.push(i);\\\\n    putMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", JSON.stringify(loadingTeam));\\\\n    updateItem({\\\\n        title: \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n        }\\\\n    });\\\\n    let result = \\\\\\\"toast://下载失败\\\\\\\";\\\\n    try {\\\\n        toast(\\\\\\\"开始下载:\\\\\\\" + item.title);\\\\n        let download = $.require(\\\\\\\"hiker://page/Download.exe.js\\\\\\\");\\\\n        result = download(item, info, MY_ID, i);\\\\n        updateItem({\\\\n            title: \\\\\\\"““\\\\\\\" + item.title + \\\\\\\"””\\\\\\\",\\\\n            url: \\\\\\\"toast://已下载\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n    } catch (e) {\\\\n        updateItem({\\\\n            title: item.title,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        log(e.toString());\\\\n    } finally {\\\\n        loadingTeam.splice(ElementIndex, 1);\\\\n        putMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", JSON.stringify(loadingTeam));\\\\n    }\\\\n    return result;\\\\n}\\\\n\\\\nfunction singleView() {\\\\n    layout.push({\\\\n        title: \\\\\\\"反转列表\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReverse, MY_ID) => {\\\\n            putMyVar(MY_ID + \\\\\\\":isReverse\\\\\\\", isReverse === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, isReverse, MY_ID),\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\\\\\",\\\\n        col_type: \\\\\\\"icon_2\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"批量下载\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            if (loadingTeam.length > 0) return \\\\\\\"toast://还有任务没有完成\\\\\\\";\\\\n            if (getAppVersion() < 2594) return \\\\\\\"toast://未开放\\\\\\\";\\\\n            putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n        }, MY_ID),\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\\\\\",\\\\n        col_type: \\\\\\\"icon_2\\\\\\\"\\\\n    });\\\\n    setType();\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\\\n        let is_download = record.includes(item.title);\\\\n        if (is_download && tagFilter !== \\\\\\\"1\\\\\\\") {\\\\n            chapterTeam.push(comFun(item.CID, item));\\\\n        } else if (!is_download && tagFilter !== \\\\\\\"2\\\\\\\") {\\\\n            chapterTeam.push({\\\\n                title: loadingTeam.includes(item.CID) ? \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\" : item.title,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"#\\\\\\\" + item.CID\\\\n                },\\\\n                col_type: def_DoVi_Style\\\\n            });\\\\n        }\\\\n    }\\\\n}\\\\n\\\\nfunction clickChoose(title, MY_ID, i) {\\\\n    let isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n    if (isStart === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在下载...\\\\\\\";\\\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let ElementIndex = batchTeam.indexOf(i);\\\\n    if (ElementIndex > -1) {\\\\n        updateItem({\\\\n            title: title,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        batchTeam.splice(ElementIndex, 1);\\\\n    } else {\\\\n        updateItem({\\\\n            title: \\\\\\\"‘‘\\\\\\\" + title + \\\\\\\"’’\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        batchTeam.push(i);\\\\n    }\\\\n    putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n}\\\\n\\\\nfunction batchView() {\\\\n    layout.push({\\\\n        title: \\\\\\\"单选下载\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\") === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在批量下载\\\\\\\";\\\\n            putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\\\n    let end = start + chapterList.length;\\\\n    layout.push({\\\\n        title: \\\\\\\"选择全部\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((start, end, MY_ID) => {\\\\n            const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n            let chooseTeam = Tool.range(start, end);\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\\\\\":completed\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, start, end, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"取消全部\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((start, end, MY_ID) => {\\\\n            const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n            let chooseTeam = new Set(Tool.range(start, end));\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, start, end, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"确认选中\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"-1\\\\\\\") !== \\\\\\\"-1\\\\\\\") {\\\\n                return \\\\\\\"toast://正在下载...\\\\\\\";\\\\n            }\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            return batchTeam.length === 0 ? \\\\\\\"toast://你还什么都没有选\\\\\\\" : \\\\\\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\\\\\";\\\\n        }, MY_ID),\\\\n        extra: {\\\\n            newWindow: true,\\\\n            windowId: MY_ID + \\\\\\\"//批量下载\\\\\\\",\\\\n            MY_ID: MY_ID,\\\\n            chapterList: backupChapterList,\\\\n            info: info\\\\n        },\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    setType();\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let completed = [];\\\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\\\n        let is_download = record.includes(item.title);\\\\n        if (is_download && tagFilter !== \\\\\\\"1\\\\\\\") {\\\\n            completed.push(item.CID);\\\\n            chapterTeam.push(comFun(item.CID, item));\\\\n        } else if (!is_download && tagFilter !== \\\\\\\"2\\\\\\\") {\\\\n            chapterTeam.push({\\\\n                title: batchTeam.includes(item.CID) ? \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\" : item.title,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"#\\\\\\\" + item.CID\\\\n                },\\\\n                col_type: def_DoVi_Style\\\\n            });\\\\n        }\\\\n    }\\\\n    putMyVar(MY_ID + \\\\\\\":completed\\\\\\\", JSON.stringify(completed));\\\\n}\\\\nswitch (viewMode) {\\\\n    case \\\\\\\"0\\\\\\\":\\\\n        singleView();\\\\n        break;\\\\n    case \\\\\\\"1\\\\\\\":\\\\n        batchView();\\\\n        break;\\\\n}\\\\nif (isReverse === \\\\\\\"1\\\\\\\") {\\\\n    chapterTeam.reverse();\\\\n}\\\\nlayout.push.apply(layout, chapterTeam);\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.批量下载器\\\",\\\"path\\\":\\\"Batch.view\\\",\\\"rule\\\":\\\"js:\\\\nlet {\\\\n    chapterList,\\\\n    info,\\\\n    MY_ID\\\\n} = MY_PARAMS;\\\\nsetPageTitle(\\\\\\\"下载器|\\\\\\\"+info.bookName);\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString((MY_ID) => {\\\\n    clearMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":status\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n    refreshPage();\\\\n}, MY_ID));\\\\n\\\\nlet isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet layout = [];\\\\n\\\\nlet batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\nif(typeof chapterList === \\\\\\\"string\\\\\\\"){\\\\n    chapterList = JSON.parse(request(\\\\\\\"file://\\\\\\\"+chapterList)||\\\\\\\"[]\\\\\\\");\\\\n}\\\\nlet chapterTeam = batchTeam.map(v => {\\\\n    let chapterItem = chapterList[v];\\\\n    chapterItem.CID = v;\\\\n    return chapterItem;\\\\n});\\\\nif (isStart === \\\\\\\"0\\\\\\\") {\\\\n    layout.push({\\\\n        title: \\\\\\\"开始下载[\\\\\\\" + chapterTeam.length + \\\\\\\"]\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((chapterTeam, info, MY_ID) => {\\\\n            putMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage(false);\\\\n            let download = $.require(\\\\\\\"hiker://page/BatchStatistics.js\\\\\\\");\\\\n            return download(chapterTeam, info, MY_ID) || \\\\\\\"toast://下载错误\\\\\\\";\\\\n        }, chapterTeam, info, MY_ID),\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||开始下载\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"任务列表：\\\\\\\",\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    });\\\\n    for (let item of chapterTeam) {\\\\n        layout.push({\\\\n            title: item.title,\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_2\\\\\\\"\\\\n        });\\\\n    }\\\\n\\\\n} else {\\\\n    layout.push({\\\\n        title: \\\\\\\"下载进度:0/\\\\\\\"+chapterTeam.length,\\\\n        desc: \\\\\\\"““””▇▇▇▇▇▇▇▇▇▇\\\\\\\".fontcolor(\\\\\\\"#e5e1e4\\\\\\\")+\\\\\\\" 0%\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||下载进度\\\\\\\",\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"后台下载\\\\\\\",\\\\n        url: \\\\\\\"func://background\\\\\\\",\\\\n        col_type: \\\\\\\"text_2\\\\\\\"\\\\n    });\\\\n\\\\n    layout.push({\\\\n        title: [\\\\\\\"[取消下载]\\\\\\\", \\\\\\\"[正在停止...]\\\\\\\", \\\\\\\"[返回]\\\\\\\", \\\\\\\"[处理失败]\\\\\\\", \\\\\\\"[重新开始]\\\\\\\"][status],\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            if (status === \\\\\\\"0\\\\\\\") {\\\\n                putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n                updateItem({\\\\n                    title: \\\\\\\"[正在停止...]\\\\\\\",\\\\n                    extra: {\\\\n                        id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                    }\\\\n                });\\\\n                return \\\\\\\"toast://正在取消下载任务\\\\\\\";\\\\n            } else if (status === \\\\\\\"1\\\\\\\") {\\\\n                return \\\\\\\"toast://正在暂停...\\\\\\\";\\\\n            } else if (status === \\\\\\\"2\\\\\\\") {\\\\n                back();\\\\n                return \\\\\\\"toast://已退出下载器\\\\\\\";\\\\n            } else if ([\\\\\\\"3\\\\\\\", \\\\\\\"4\\\\\\\"].includes(status)) {\\\\n                clearMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n                clearMyVar(MY_ID + \\\\\\\":status\\\\\\\");\\\\n                clearMyVar(MY_ID + \\\\\\\":log\\\\\\\");\\\\n                refreshPage();\\\\n                return \\\\\\\"toast://重新点击下载\\\\\\\"\\\\n            }\\\\n        }, MY_ID),\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"<strong>下载日志</strong>\\\\\\\".big(),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n        \\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||日志\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title:\\\\\\\"““””$>\\\\\\\"+\\\\\\\"开始下载......\\\\\\\".fontcolor(\\\\\\\"#00ff00\\\\\\\"),\\\\n        url:\\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"#log#0\\\\\\\",\\\\n            lineVisible:false\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.批量下载统计\\\",\\\"path\\\":\\\"BatchStatistics.js\\\",\\\"rule\\\":\\\"const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nfunction task(taskParam) {\\\\n    let result = $.require(\\\\\\\"hiker://page/Batch.exe.js\\\\\\\")(taskParam);\\\\n    return result;\\\\n}\\\\n\\\\n$.exports = function(chapterTeam, info, MY_ID) {\\\\n    if (chapterTeam.length === 0) {\\\\n        return \\\\\\\"toast://空的下载队列\\\\\\\";\\\\n    }\\\\n    var count = 0;\\\\n    var taskCount = chapterTeam.length;\\\\n    var successCID = [];\\\\n    var failName = [];\\\\n    var logCount = 1;\\\\n    var taskTeam = chapterTeam.map(chapterItem => ({\\\\n        func: task,\\\\n        id: chapterItem.title,\\\\n        param: {\\\\n            chapterItem: chapterItem,\\\\n            info: info,\\\\n            MY_ID: MY_ID\\\\n        }\\\\n    }));\\\\n    let logNum = Config.logNum;\\\\n\\\\n    function putLog(text) {\\\\n        log(text);\\\\n        if (logCount >= logNum) {\\\\n            deleteItem(MY_ID + \\\\\\\"#log#\\\\\\\" + (logCount - 10));\\\\n        }\\\\n        addItemAfter(MY_ID + \\\\\\\"||日志\\\\\\\", {\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            title: \\\\\\\"$>\\\\\\\" + text,\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false,\\\\n                id: MY_ID + \\\\\\\"#log#\\\\\\\" + logCount\\\\n            }\\\\n        });\\\\n        logCount++;\\\\n    }\\\\n\\\\n    function listener(perch, id, error, CID) {\\\\n        count++;\\\\n        let isSuccess = false;\\\\n        if (error !== null) {\\\\n            failName.push(id);\\\\n            putLog(\\\\\\\"[listener]下载失败：\\\\\\\" + id + \\\\\\\"<ERROR@ \\\\\\\" + error + \\\\\\\">\\\\\\\");\\\\n        } else if (CID >= 0) {\\\\n            successCID.push(CID);\\\\n            let ratio = (count / taskCount).toFixed(4);\\\\n            let stripCount = Math.ceil(ratio * 10);\\\\n            isSuccess = true;\\\\n            updateItem({\\\\n                title: \\\\\\\"下载进度：\\\\\\\" + successCID.length + \\\\\\\"/\\\\\\\" + taskCount,\\\\n                desc: \\\\\\\"““””\\\\\\\" + \\\\\\\"▇\\\\\\\".repeat(stripCount).fontcolor(\\\\\\\"#ffac2d\\\\\\\") + \\\\\\\"▇\\\\\\\".repeat(10 - stripCount).fontcolor(\\\\\\\"#e5e1e4\\\\\\\") + \\\\\\\" \\\\\\\" + (ratio * 100) + \\\\\\\"%\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载进度\\\\\\\"\\\\n                }\\\\n            });\\\\n            putLog(\\\\\\\"[listener]已完成下载：\\\\\\\" + id);\\\\n        } else if (CID === -1) {\\\\n            failName.push(id);\\\\n            putLog(\\\\\\\"[listener]已停止：\\\\\\\" + id);\\\\n        }\\\\n        if (taskCount !== count) return;\\\\n        if (successCID.length === taskCount) {\\\\n            updateItem({\\\\n                desc: \\\\\\\"““””\\\\\\\" + \\\\\\\"▇\\\\\\\".repeat(10).fontcolor(\\\\\\\"#00ff00\\\\\\\") + \\\\\\\" 100%\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载进度\\\\\\\"\\\\n                }\\\\n            });\\\\n        }\\\\n        let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n        let failTeam = batchTeam.filter(v => !successCID.includes(v));\\\\n        putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(failTeam));\\\\n        if (failTeam.length > 0 && status !== \\\\\\\"1\\\\\\\") {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"3\\\\\\\");\\\\n            putLog(\\\\\\\"下载失败:[\\\\\\\" + failName.join(\\\\\\\"]，[\\\\\\\") + \\\\\\\"]。\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[处理失败]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        } else if (failTeam.length > 0 && status === \\\\\\\"1\\\\\\\") {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"4\\\\\\\");\\\\n            putLog(\\\\\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[重新开始]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        } else {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"2\\\\\\\");\\\\n            putLog(\\\\\\\"下载任务[\\\\\\\" + info.bookName + \\\\\\\"]已全部成功完成\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[返回]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        }\\\\n        toast(\\\\\\\"下载任务[\\\\\\\" + info.bookName + \\\\\\\"]已完成\\\\\\\");\\\\n    }\\\\n    let taskTeamChunk = [];\\\\n    if (Config.threadNum > 0) {\\\\n        taskTeamChunk = Tool.chunk(taskTeam, Config.threadNum);\\\\n    } else {\\\\n        taskTeamChunk = [taskTeam];\\\\n    }\\\\n    for (let taskList of taskTeamChunk) {\\\\n        be(taskList, {\\\\n            func: listener\\\\n        });\\\\n        let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n        if (status === \\\\\\\"1\\\\\\\") {\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            let failTeam = batchTeam.filter(v => !successCID.includes(v));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(failTeam));\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"4\\\\\\\");\\\\n            putLog(\\\\\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[重新开始]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }\\\\n\\\\n    }\\\\n\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.批量主程序\\\",\\\"path\\\":\\\"Batch.exe.js\\\",\\\"rule\\\":\\\"const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n\\\\nfunction comic(taskParam) {\\\\n    let {\\\\n        chapterItem,\\\\n        info,\\\\n        MY_ID,\\\\n    } = taskParam;\\\\n    if (getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n        return -1;\\\\n    }\\\\n    let mainPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + chapterItem.CID + \\\\\\\"$B$\\\\\\\" + chapterItem.title + \\\\\\\"/\\\\\\\";\\\\n    let picList;\\\\n    try {\\\\n        let getPicList = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"return \\\\\\\" + info.parseCode);\\\\n        picList = getPicList(chapterItem.url, chapterItem.url);\\\\n        if (typeof picList === \\\\\\\"string\\\\\\\") {\\\\n            picList = picList.replace(\\\\\\\"pics://\\\\\\\", \\\\\\\"\\\\\\\").split(\\\\\\\"&&\\\\\\\");\\\\n        }\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<漫画图片解析错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\";\\\\n        throw e;\\\\n    }\\\\n    const L = picList.length;\\\\n    if(L===0){\\\\n        throw new Error(\\\\\\\"<漫画图片解析错误：图片链接返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\");\\\\n        }\\\\n    }\\\\n    var schedule = new Map([\\\\n        [L, () => log(chapterItem.title + \\\\\\\"已下载100%\\\\\\\")],\\\\n        [~~(0.90 * L), () => log(chapterItem.title + \\\\\\\"已下载90%+\\\\\\\")],\\\\n        [~~(0.75 * L), () => log(chapterItem.title + \\\\\\\"已下载75%+\\\\\\\")],\\\\n        [~~(0.50 * L), () => log(chapterItem.title + \\\\\\\"已下载50%+\\\\\\\")],\\\\n        [~~(0.25 * L), () => log(chapterItem.title + \\\\\\\"已下载25%+\\\\\\\")]\\\\n    ]);\\\\n    for (var i = 0; i < L; i++) {\\\\n        let pic = Tool.hikerPic(picList[i]);\\\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\\\\\".jpg\\\\\\\", pic[1]);\\\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\\\n        if (getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n            return -1;\\\\n        }\\\\n    }\\\\n    File.renameFile(chapterPath, chapterItem.CID + \\\\\\\"$A$\\\\\\\" + chapterItem.title);\\\\n    return chapterItem.CID;\\\\n}\\\\n\\\\nfunction novel(taskParam) {\\\\n    let {\\\\n        chapterItem,\\\\n        info,\\\\n        MY_ID,\\\\n    } = taskParam;\\\\n    if (getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n        return -1;\\\\n    }\\\\n    let mainPath = Config.novelPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + chapterItem.CID + \\\\\\\"$A$\\\\\\\" + chapterItem.title + \\\\\\\".txt\\\\\\\";\\\\n    let content = \\\\\\\"\\\\\\\";\\\\n    try {\\\\n        let getContent = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"return \\\\\\\" + info.parseCode);\\\\n        content = getContent(chapterItem.url, chapterItem.url);\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<小说正文解析错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\";\\\\n        throw e;\\\\n    }\\\\n    if (!content) {\\\\n        throw new Error(\\\\\\\"<小说正文解析错误：正文返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\");\\\\n        }\\\\n    }\\\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\\\\\/script>/gmi, \\\\\\\"\\\\\\\").trimRight());\\\\n    //File.renameFile(chapterPath, chapterItem.CID + \\\\\\\"$A$\\\\\\\" + chapterItem.title);\\\\n    return chapterItem.CID;\\\\n}\\\\nvar $exe = {\\\\n    comic: comic,\\\\n    novel: novel\\\\n};\\\\n$.exports = function(taskParam) {\\\\n    return $exe[taskParam.info.type](taskParam);\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.普通主程序\\\",\\\"path\\\":\\\"Download.exe.js\\\",\\\"rule\\\":\\\"const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n\\\\nfunction novel(item, info, MY_ID, order) {\\\\n    let mainPath = Config.novelPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + order + \\\\\\\"$A$\\\\\\\" + item.title + \\\\\\\".txt\\\\\\\";\\\\n    let content = \\\\\\\"\\\\\\\";\\\\n    try {\\\\n        let getContent = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"return \\\\\\\" + info.parseCode);\\\\n        content = getContent(item.url, item.url) || \\\\\\\"\\\\\\\";\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<小说正文解析错误> \\\\\\\" + e.message;\\\\n        throw e;\\\\n    }\\\\n    if (!content) {\\\\n        toast(\\\\\\\"小说为空\\\\\\\");\\\\n        throw new Error(\\\\\\\"<小说正文解析错误：正文返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误> \\\\\\\" + e.message);\\\\n        }\\\\n    }\\\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\\\\\/script>/gmi, \\\\\\\"\\\\\\\").trimRight());\\\\n    //File.renameFile(chapterPath, order + \\\\\\\"$A$\\\\\\\" + item.title + \\\\\\\".txt\\\\\\\");\\\\n    return \\\\\\\"toast://\\\\\\\" + info.bookName + \\\\\\\"@\\\\\\\" + item.title + \\\\\\\" 下载完成\\\\\\\";\\\\n}\\\\n\\\\nfunction comic(item, info, MY_ID, order) {\\\\n    let mainPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + order + \\\\\\\"$B$\\\\\\\" + item.title + \\\\\\\"/\\\\\\\";\\\\n    let picList = [];\\\\n    try {\\\\n        let getPicList = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"return\\\\\\\" + info.parseCode);\\\\n        picList = getPicList(item.url);\\\\n        if (typeof picList === \\\\\\\"string\\\\\\\") {\\\\n            picList = picList.replace(\\\\\\\"pics://\\\\\\\", \\\\\\\"\\\\\\\").split(\\\\\\\"&&\\\\\\\");\\\\n        }\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<漫画图片解析错误> \\\\\\\" + e.message;\\\\n        throw e;\\\\n    }\\\\n\\\\n    const L = picList.length;\\\\n    if(L===0){\\\\n        toast(\\\\\\\"图片链接为空\\\\\\\");\\\\n        throw new Error(\\\\\\\"<漫画图片解析错误：图片链接返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误> \\\\\\\" + e.message);\\\\n        }\\\\n    }\\\\n    var schedule = new Map([\\\\n        [L, () => log(item.title + \\\\\\\"已下载100%\\\\\\\")],\\\\n        [~~(0.90 * L), () => log(item.title + \\\\\\\"已下载90%+\\\\\\\")],\\\\n        [~~(0.75 * L), () => log(item.title + \\\\\\\"已下载75%+\\\\\\\")],\\\\n        [~~(0.50 * L), () => log(item.title + \\\\\\\"已下载50%+\\\\\\\")],\\\\n        [~~(0.25 * L), () => log(item.title + \\\\\\\"已下载25%+\\\\\\\")]\\\\n    ]);\\\\n\\\\n    for (var i = 0; i < L; i++) {\\\\n        let pic = Tool.hikerPic(picList[i]);\\\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\\\\\".jpg\\\\\\\", pic[1]);\\\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\\\n    }\\\\n\\\\n    File.renameFile(chapterPath, order + \\\\\\\"$A$\\\\\\\" + item.title);\\\\n    return \\\\\\\"toast://\\\\\\\" + info.bookName + \\\\\\\"@\\\\\\\" + item.title + \\\\\\\" 下载完成\\\\\\\";\\\\n}\\\\nvar $exe = {\\\\n    comic: comic,\\\\n    novel: novel\\\\n};\\\\n$.exports = function(item, info, MY_ID, order) {\\\\n    return $exe[info.type](item, info, MY_ID, order);\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#f.通用工具\\\",\\\"path\\\":\\\"Tool.js\\\",\\\"rule\\\":\\\"$.exports = {\\\\n    split(text, target, count) {\\\\n        count = count === undefined ? 1 : count;\\\\n        let array = [text];\\\\n        for (let i = 0; i < count; i++) {\\\\n            text = array[i];\\\\n            let index = text.indexOf(target);\\\\n            if (index === -1) {\\\\n                break;\\\\n            }\\\\n            array[i] = text.slice(0, index);\\\\n            array[i + 1] = text.slice(index + target.length);\\\\n        }\\\\n        return array;\\\\n    },\\\\n    chunk(arr, size) {\\\\n        var result = [];\\\\n        for (var i = 0, len = arr.length; i < len; i += size) {\\\\n            result.push(arr.slice(i, i + size));\\\\n        }\\\\n        return result;\\\\n    },\\\\n    hikerPic(url) {\\\\n        var headers = {};\\\\n        let urls = url.split(\\\\\\\"@\\\\\\\");\\\\n        let picUrl = urls.shift();\\\\n        let length = urls.length;\\\\n        for (let i = 0; i < length; i++) {\\\\n            let [key, value] = urls[i].split(\\\\\\\"=\\\\\\\");\\\\n            headers[key] = value;\\\\n        }\\\\n        return [picUrl, headers];\\\\n    },\\\\n    range(start, end) {\\\\n        return Array(end - start).fill(0).map((el, i) => start + i);\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#j.Config\\\",\\\"path\\\":\\\"Config.json\\\",\\\"rule\\\":\\\"const Config = Object.assign({\\\\n    homePath: \\\\\\\"/storage/emulated/0/Android/data/com.example.hikerview/files/Documents/localManager\\\\\\\",\\\\n    logNum: 10,\\\\n    threadNum: 16,\\\\n    def_isPaginate: \\\\\\\"1\\\\\\\", //1默认开启分页，0默认关闭\\\\n    viewPageSize: 200,\\\\n    def_Pic: \\\\\\\"hiker://images/home_pic4\\\\\\\",\\\\n    def_Lord_Type: \\\\\\\"comic\\\\\\\",\\\\n    def_View_Style: \\\\\\\"text_1\\\\\\\",\\\\n    def_DoVi_Style: \\\\\\\"text_2\\\\\\\",\\\\n    def_DoVi_Type: \\\\\\\"1\\\\\\\", //0全部, 1未完成，2已完成\\\\n}, JSON.parse(readFile(\\\\\\\"config.json\\\\\\\") || \\\\\\\"{}\\\\\\\"));\\\\nconst PATHS = {\\\\n    novelPath: \\\\\\\"/小说/\\\\\\\",\\\\n    comicPath: \\\\\\\"/漫画/\\\\\\\",\\\\n    novelFullPath: \\\\\\\"/小说合并/\\\\\\\"\\\\n}\\\\n\\\\n\\\\nObject.keys(PATHS).forEach(key => Config[key] = Config.homePath + PATHS[key]);\\\\n$.exports = Config;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.主页面\\\",\\\"path\\\":\\\"Main.view\\\",\\\"rule\\\":\\\"js:\\\\nfunction main() {\\\\n    var layout = [];\\\\n    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n    const Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n    let type = getMyVar(\\\\\\\".type\\\\\\\", Config.def_Lord_Type);\\\\n    let tag = File.getFilePath(Config[type + \\\\\\\"Path\\\\\\\"], \\\\\\\"dir\\\\\\\");\\\\n    let tgnum = getMyVar(\\\\\\\".tgnum\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n    addListener(\\\\\\\"onClose\\\\\\\", $.toString((MY_ID) => {\\\\n        clearMyVar(\\\\\\\"searchKey\\\\\\\");\\\\n        clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n    }));\\\\n    layout.push({\\\\n        title: type === \\\\\\\"comic\\\\\\\" ? \\\\\\\"◉漫画\\\\\\\" : \\\\\\\"○漫画\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((type) => {\\\\n            if (type === \\\\\\\"comic\\\\\\\") return \\\\\\\"hiker://empty\\\\\\\";\\\\n            putMyVar(\\\\\\\".type\\\\\\\", \\\\\\\"comic\\\\\\\");\\\\n            clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, type),\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n    });\\\\n    layout.push({\\\\n        title: type === \\\\\\\"novel\\\\\\\" ? \\\\\\\"◉小说\\\\\\\" : \\\\\\\"○小说\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((type) => {\\\\n            if (type === \\\\\\\"novel\\\\\\\") return \\\\\\\"hiker://page/NovelCollected.view#noRecordHistory##noHistory#\\\\\\\";\\\\n            putMyVar(\\\\\\\".type\\\\\\\", \\\\\\\"novel\\\\\\\");\\\\n            clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, type),\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n    });\\\\n    if (tag.length === 0) {\\\\n        layout.push({\\\\n            title: \\\\\\\"““””\\\\\\\" + \\\\\\\"一本也没有\\\\\\\".big(),\\\\n            url: \\\\\\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            extra: {\\\\n                version: MY_RULE.version,\\\\n                lineVisible: false\\\\n            }\\\\n        })\\\\n        return setResult(layout);\\\\n    }\\\\n    layout.push({\\\\n        url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n        desc: \\\\\\\"搜你想要的#\\\\\\\" + type + \\\\\\\"#......\\\\\\\",\\\\n        title: '搜索',\\\\n        col_type: 'input',\\\\n        extra: {\\\\n            rules: $.toString((tag, type) => {\\\\n                let arr1 = [];\\\\n                for (let i = 0; i < tag.length; i++) {\\\\n                    arr1.push({\\\\n                        \\\\\\\"title\\\\\\\": tag[i].name,\\\\n                        \\\\\\\"search_url\\\\\\\": \\\\\\\"hiker://empty?isAll=1&searchTerms=**&type=\\\\\\\" + type,\\\\n                        \\\\\\\"searchFind\\\\\\\": \\\\\\\"js:$.require('hiker://page/Search.view?rule='+MY_RULE._title);\\\\\\\"\\\\n                    });\\\\n                }\\\\n\\\\n                return JSON.stringify(arr1);\\\\n            }, tag, type),\\\\n            defaultValue: getMyVar('searchKey', ''),\\\\n            onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n        }\\\\n    });\\\\n    \\\\n    layout.push({\\\\n        title: \\\\\\\"‘‘⚙设置’’\\\\\\\",\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\\\\\",\\\\n        extra:{\\\\n            version: MY_RULE.version\\\\n        }\\\\n    });\\\\n    \\\\n\\\\n    for (let i in tag) {\\\\n        let it = tag[i];\\\\n        if (tgnum === i) {\\\\n            layout.push({\\\\n                title: \\\\\\\"““\\\\\\\" + it.name + \\\\\\\"””\\\\\\\",\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $U.build($U([\\\\\\\"删除该目录\\\\\\\", \\\\\\\"跳转小程序\\\\\\\"], 1, \\\\\\\"选择操作\\\\\\\").select((name) => {\\\\n                    if (\\\\\\\"跳转小程序\\\\\\\" === input) {\\\\n                        return \\\\\\\"hiker://home@\\\\\\\" + name;\\\\n                    } else {\\\\n                        return then([\\\\\\\"该操作不会删除小程序，但该小程序下载的所有漫画将被删除\\\\\\\"]);\\\\n                    }\\\\n                }, it.name).confirm((path) => {\\\\n                    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                    if (File.deleteFlies(path)) {\\\\n                        clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n                        refreshPage();\\\\n                        return \\\\\\\"toast://删除成功\\\\\\\";\\\\n                    } else {\\\\n                        return \\\\\\\"toast://删除失败\\\\\\\";\\\\n                    }\\\\n                }, it.path))\\\\n            });\\\\n        } else {\\\\n            layout.push({\\\\n                title: it.name,\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(i => {\\\\n                    putMyVar(\\\\\\\".tgnum\\\\\\\", i);\\\\n                    refreshPage();\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }, i),\\\\n            });\\\\n        }\\\\n    }\\\\n    let path = tag[tgnum].path;\\\\n    let mhlist = File.getFilePath(path, \\\\\\\"dir\\\\\\\");\\\\n\\\\n    if (mhlist.length === 0) {\\\\n        layout.push({\\\\n            title: \\\\\\\"““””\\\\\\\" + \\\\\\\"一本也没有\\\\\\\".big(),\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        })\\\\n        return setResult(layout);\\\\n    }\\\\n    let pageUrl = type === \\\\\\\"novel\\\\\\\" ? \\\\\\\"hiker://page/NovelBrowser.view\\\\\\\" : \\\\\\\"hiker://page/ComicBrowser.view\\\\\\\";\\\\n    for (let item of mhlist) {\\\\n        let pic = fileExist(\\\\\\\"file://\\\\\\\" + item.path + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\".jpg\\\\\\\") ? item.path + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\".jpg\\\\\\\" : Config.def_Pic;\\\\n        layout.push({\\\\n            title: item.name,\\\\n            pic_url: pic,\\\\n            url: pageUrl + \\\\\\\"?rule=\\\\\\\" + MY_RULE.title,\\\\n            extra: item\\\\n        });\\\\n    }\\\\n    setResult(layout);\\\\n}\\\\nmain();\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.漫画查看\\\",\\\"path\\\":\\\"ComicBrowser.view\\\",\\\"rule\\\":\\\"js:\\\\nif (getParam(\\\\\\\"hasParams\\\\\\\") === \\\\\\\"true\\\\\\\") {\\\\n    MY_PARAMS = {\\\\n        path: decodeURIComponent(getParam(\\\\\\\"path\\\\\\\")),\\\\n        name: decodeURIComponent(getParam(\\\\\\\"name\\\\\\\"))\\\\n    }\\\\n}\\\\nlet path = MY_PARAMS.path;\\\\nsetPageTitle(\\\\\\\"CV|\\\\\\\" + MY_PARAMS.name)\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nvar layout = [];\\\\nlet mode = getMyVar(\\\\\\\".mode\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet isReverse = getMyVar(\\\\\\\".isReverse\\\\\\\", \\\\\\\"0\\\\\\\");\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\".mode\\\\\\\");\\\\n    clearMyVar(\\\\\\\".isReverse\\\\\\\");\\\\n}));\\\\nconst comicStatus=new Map([[\\\\\\\"A\\\\\\\",\\\\\\\"\\\\\\\"],[\\\\\\\"B\\\\\\\",\\\\\\\"‘‘[未完成]’’\\\\\\\"]]);\\\\nfunction getTitle(title) {\\\\n    let titles = Tool.split(title, \\\\\\\"$\\\\\\\", 2);\\\\n    return comicStatus.get(titles[1])+titles[2] || title;\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"删除整本\\\\\\\",\\\\n    url: $(\\\\\\\"确认删除整本漫画？\\\\\\\").confirm((path) => {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        if (File.deleteFlies(path)) {\\\\n            back();\\\\n            return \\\\\\\"toast://删除成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://删除失败\\\\\\\";\\\\n        }\\\\n    }, path),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: [\\\\\\\"看漫画\\\\\\\", \\\\\\\"删除章节\\\\\\\"][mode],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((mode) => {\\\\n        putMyVar(\\\\\\\".mode\\\\\\\", mode === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, mode),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n})\\\\nlet mhlist = File.getFilePath(path, \\\\\\\"dir\\\\\\\");\\\\nmhlist.sort((a, b) => {\\\\n    a = (a.name.match(/\\\\\\\\d+/) || [])[0] || 0;\\\\n    b = (b.name.match(/\\\\\\\\d+/) || [])[0] || 0;\\\\n    return a - b;\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"““””\\\\\\\" + \\\\\\\"章节 \\\\\\\".big() + (\\\\\\\"共有:\\\\\\\" + mhlist.length + \\\\\\\"章\\\\\\\").small(),\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReverse) => {\\\\n        putMyVar(\\\\\\\".isReverse\\\\\\\", isReverse === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, isReverse),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlet array = [];\\\\nlet lazy = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n    let filelist = File.getFilePath(input);\\\\n    let piclist = filelist.map((item, i) => \\\\\\\"file://\\\\\\\" + input + \\\\\\\"/\\\\\\\" + (i + 1) + \\\\\\\".jpg\\\\\\\");\\\\n    return \\\\\\\"pics://\\\\\\\" + piclist.join(\\\\\\\"&&\\\\\\\");\\\\n})\\\\nif (mode === \\\\\\\"0\\\\\\\") {\\\\n    for (let item of mhlist) {\\\\n        array.push({\\\\n            title: getTitle(item.name),\\\\n            url: item.path+lazy,\\\\n            col_type: Config.def_View_Style\\\\n        });\\\\n    }\\\\n} else {\\\\n    for (let item of mhlist) {\\\\n        let name = getTitle(item.name);\\\\n        array.push({\\\\n            title: name,\\\\n            url: $(\\\\\\\"确认删除[\\\\\\\" + name + \\\\\\\"]？\\\\\\\").confirm((path) => {\\\\n                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                if (File.deleteFlies(path)) {\\\\n                    refreshPage(true);\\\\n                    return \\\\\\\"toast://删除成功\\\\\\\";\\\\n                } else {\\\\n                    return \\\\\\\"toast://删除失败\\\\\\\";\\\\n                }\\\\n            }, item.path),\\\\n            col_type: Config.def_View_Style\\\\n        });\\\\n    }\\\\n}\\\\nif (isReverse === \\\\\\\"1\\\\\\\") {\\\\n    array.reverse();\\\\n}\\\\nlayout.push.apply(layout, array);\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.聚合搜索\\\",\\\"path\\\":\\\"Search.view\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js?rule=\\\\\\\" + MY_RULE._title);\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json?rule=\\\\\\\" + MY_RULE._title);\\\\nlet comicRuleDirs = File.getFilePath(Config[getParam(\\\\\\\"type\\\\\\\")+\\\\\\\"Path\\\\\\\"], \\\\\\\"dir\\\\\\\");\\\\nif (getParam(\\\\\\\"isAll\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n    comicRuleDirs = comicRuleDirs.filter(item => item.name === MY_RULE.title);\\\\n}\\\\n\\\\nlet searchResult = [];\\\\nlet searchTerms = getParam(\\\\\\\"searchTerms\\\\\\\");\\\\nlet termsArr = searchTerms.split(\\\\\\\"\\\\\\\").map(t => t.replace(/\\\\\\\\*|\\\\\\\\.|\\\\\\\\?|\\\\\\\\+|\\\\\\\\$|\\\\\\\\^|\\\\\\\\[|\\\\\\\\]|\\\\\\\\(|\\\\\\\\)|\\\\\\\\{|\\\\\\\\}|\\\\\\\\||\\\\\\\\/|\\\\\\\\\\\\\\\\/g, k => \\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\" + k));\\\\nlet reg = new RegExp(termsArr.join(\\\\\\\".*\\\\\\\"),\\\\\\\"i\\\\\\\");\\\\nlet pageUrl=getParam(\\\\\\\"type\\\\\\\")===\\\\\\\"novel\\\\\\\"?\\\\\\\"hiker://page/NovelBrowser.view\\\\\\\":\\\\\\\"hiker://page/ComicBrowser.view\\\\\\\";\\\\nfor (let sonDir of comicRuleDirs) {\\\\n    let comicList = File.getFilePath(sonDir.path, \\\\\\\"dir\\\\\\\");\\\\n    for (let comic of comicList) {\\\\n        if (reg.test(comic.name)) {\\\\n            searchResult.push({\\\\n                title: comic.name,\\\\n                pic_url: comic.path + \\\\\\\"/\\\\\\\" + comic.name + \\\\\\\".jpg\\\\\\\",\\\\n                url: pageUrl+\\\\\\\"?rule=\\\\\\\" + MY_RULE._title,\\\\n                desc: sonDir.name,\\\\n                extra: comic\\\\n            });\\\\n        }\\\\n    }\\\\n\\\\n}\\\\nsetResult(searchResult);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.设置\\\",\\\"path\\\":\\\"Setting.view\\\",\\\"rule\\\":\\\"js:\\\\nsetPageTitle(MY_RULE.title + \\\\\\\"|设置\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nlet layout = [];\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>基础设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"目录路径\\\\\\\",\\\\n    url: $(Config.homePath, \\\\\\\"支持hiker://files路径\\\\\\\\n(该操作不会初始化目录)\\\\\\\").input(() => {\\\\n        const Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n        if (input.startsWith(\\\\\\\"hiker://files/\\\\\\\")) input = getPath(input).slice(7);\\\\n        if (Config.homePath == input) return \\\\\\\"toast://已经是当前目录\\\\\\\";\\\\n        Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n        Config.homePath = input;\\\\n        saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config));\\\\n        refreshPage(false);\\\\n        return \\\\\\\"toast://已保存\\\\\\\";\\\\n    }),\\\\n    desc: Config.homePath,\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"设置默认封面\\\\\\\",\\\\n    desc: Config.def_Pic,\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRefresh##noRecordHistory##noHistory#?settingType=defaultPic\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>下载器设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\n\\\\nfunction setNum(key, test) {\\\\n    let Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n    input = parseInt(input);\\\\n    if (Number.isNaN(input)) return \\\\\\\"toast://请输入数字\\\\\\\";\\\\n    if (!test(input)) return \\\\\\\"toast://不符合条件\\\\\\\";\\\\n    Config[key] = input;\\\\n    saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config));\\\\n    refreshPage(false);\\\\n    return \\\\\\\"toast://修改成功\\\\\\\";\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"log数\\\\\\\",\\\\n    url: $(Config.logNum, \\\\\\\"0<N<100\\\\\\\").input(setNum, \\\\\\\"logNum\\\\\\\", it => it > 0 && it < 100),\\\\n    desc: \\\\\\\"\\\\\\\" + Config.logNum,\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"分批下载数(0不开启)\\\\\\\",\\\\n    url: $(\\\\\\\"\\\\\\\" + Config.threadNum, \\\\\\\"N>-1\\\\\\\").input(setNum, \\\\\\\"threadNum\\\\\\\", it => it > -1),\\\\n    desc: \\\\\\\"\\\\\\\" + Config.threadNum,\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false,\\\\n    }\\\\n});\\\\n\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>小说阅读器设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"默认开启分页阅读\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((def_isPaginate) => {\\\\n        let Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n\\\\n        Config.def_isPaginate = def_isPaginate === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\";\\\\n\\\\n        saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config));\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, Config.def_isPaginate),\\\\n    desc: Config.def_isPaginate === \\\\\\\"0\\\\\\\" ? \\\\\\\"不开启\\\\\\\" : \\\\\\\"开启\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"每页最大章数\\\\\\\",\\\\n    url: $(Config.viewPageSize, \\\\\\\"30<N<500\\\\\\\").input(setNum, \\\\\\\"viewPageSize\\\\\\\", it => it > 30 && it < 500),\\\\n    desc: \\\\\\\"\\\\\\\" + Config.viewPageSize,\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"替换规则\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRecordHistory##noHistory##noRefresh#?settingType=replaceRule\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>其他设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"规则发布页\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\\\\\",\\\\n    extra: {\\\\n        lver: MY_PARAMS.version || \\\\\\\"获取版本失败，自行查看\\\\\\\",\\\\n        id: \\\\\\\"3559\\\\\\\"\\\\n    },\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"关于如何调用\\\\\\\",\\\\n    url: \\\\\\\"https://qun.qq.com/qqweb/qunpro/share?_wv=3&_wwv=128&inviteCode=1HFyBJ&from=246610&biz=ka\\\\\\\",\\\\n    desc: \\\\\\\"详细点击加入频道，频道里@LoyDgIk\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"恢复默认设置\\\\\\\",\\\\n    url: $(\\\\\\\"确认恢复默认设置？\\\\\\\").confirm(() => {\\\\n        deleteFile(\\\\\\\"config.json\\\\\\\");\\\\n        refreshPage(false);\\\\n        return \\\\\\\"toast://恢复完成\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"清理缓存\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRecordHistory##noHistory#?settingType=cache\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n/*\\\\nlayout.push({\\\\n    title: \\\\\\\"清除小说分页记录\\\\\\\",\\\\n    url: $(\\\\\\\"确认清除小说分页记录？\\\\\\\").confirm(() => {\\\\n        deleteFile(\\\\\\\"novelFootprint.json\\\\\\\");\\\\n        return \\\\\\\"toast://清除完成\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n*/\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.小说查看\\\",\\\"path\\\":\\\"NovelBrowser.view\\\",\\\"rule\\\":\\\"js:\\\\nif (getParam(\\\\\\\"hasParams\\\\\\\") === \\\\\\\"true\\\\\\\") {\\\\n    MY_PARAMS = {\\\\n        path: decodeURIComponent(getParam(\\\\\\\"path\\\\\\\")),\\\\n        name: decodeURIComponent(getParam(\\\\\\\"name\\\\\\\"))\\\\n    }\\\\n}\\\\nlet path = MY_PARAMS.path;\\\\nsetPageTitle(\\\\\\\"NV|\\\\\\\" + MY_PARAMS.name);\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\nconst bookInfo = Object.assign({\\\\n    foot: 0,\\\\n    isReplace: true\\\\n}, JSON.parse(request(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\"));\\\\nlet id = \\\\\\\"#\\\\\\\" + new Date().getTime();\\\\nvar layout = [];\\\\nlet mode = getMyVar(\\\\\\\".mode\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet mode2 = getMyVar(\\\\\\\".mode2\\\\\\\", Config.def_isPaginate);\\\\n\\\\nlet isReverse = getMyVar(\\\\\\\".isReverse\\\\\\\", \\\\\\\"0\\\\\\\");\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\".mode\\\\\\\");\\\\n    clearMyVar(\\\\\\\".mode2\\\\\\\");\\\\n    clearMyVar(\\\\\\\".isReverse\\\\\\\");\\\\n    clearMyVar(\\\\\\\".pageNum\\\\\\\");\\\\n}));\\\\n\\\\nfunction getTitle(title) {\\\\n    let titles = Tool.split(title, \\\\\\\"$\\\\\\\", 2);\\\\n    return titles[2] !== undefined ? titles[2].slice(0, titles[2].lastIndexOf(\\\\\\\".\\\\\\\")) : title;\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"删除整本\\\\\\\",\\\\n    url: $(\\\\\\\"确认删除整本小说？\\\\\\\").confirm((path) => {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        if (File.deleteFlies(path)) {\\\\n            back();\\\\n            return \\\\\\\"toast://删除成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://删除失败\\\\\\\";\\\\n        }\\\\n    }, path),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: [\\\\\\\"看小说\\\\\\\", \\\\\\\"删除章节\\\\\\\"][mode],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((mode) => {\\\\n        putMyVar(\\\\\\\".mode\\\\\\\", mode === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, mode),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"‘‘更多功能→’’\\\\\\\",\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n});\\\\n\\\\nfunction txt(paths, isReplace) {\\\\n    showLoading(\\\\\\\"正在合并...\\\\\\\");\\\\n    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n    const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n    const Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\n    let filelist = File.getFilePath(paths.path, \\\\\\\"file\\\\\\\", \\\\\\\".txt\\\\\\\");\\\\n    let listLength = filelist.length;\\\\n    if (listLength === 0) {\\\\n        hideLoading();\\\\n        return \\\\\\\"toast://空的章节\\\\\\\";\\\\n    }\\\\n    let bufilelist = [];\\\\n    for (let i = 0; i < listLength; i++) {\\\\n        let file = filelist[i];\\\\n        let fileInfo = Tool.split(file.name, \\\\\\\"$\\\\\\\", 2);\\\\n        bufilelist.push({\\\\n            name: fileInfo[2].slice(0, fileInfo[2].lastIndexOf(\\\\\\\".\\\\\\\")),\\\\n            path: \\\\\\\"file://\\\\\\\" + file.path,\\\\n            id: Number(fileInfo[0]) || 0\\\\n        });\\\\n    }\\\\n    bufilelist.sort((a, b) => a.id - b.id);\\\\n    let entirePath = paths.path.replace(Config.novelPath, Config.novelFullPath) + \\\\\\\".txt\\\\\\\";\\\\n    let entirePathto = isReplace ? entirePath + \\\\\\\".tmp\\\\\\\" : entirePath;\\\\n\\\\n    if (fileExist(\\\\\\\"file://\\\\\\\" + entirePath)) {\\\\n        toast(\\\\\\\"初始化文件\\\\\\\");\\\\n        if (!File.deleteFlies(entirePath)) {\\\\n            hideLoading();\\\\n            return \\\\\\\"toast://初始化失败\\\\\\\";\\\\n        } else {\\\\n            toast(\\\\\\\"初始化成功\\\\\\\");\\\\n        }\\\\n    }\\\\n\\\\n    for (let i = 0; i < listLength; i++) {\\\\n        let item = bufilelist[i];\\\\n        let content = request(item.path);\\\\n        File.fileWriteAppend(entirePathto, item.name + \\\\\\\"\\\\\\\\n　　\\\\\\\" + content.replace(/^\\\\\\\\s+|\\\\\\\\s+$/gm, \\\\\\\"\\\\\\\").split(/\\\\\\\\n+/).join(\\\\\\\"\\\\\\\\r　　\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\\n\\\\\\\");\\\\n    }\\\\n    if (isReplace) {\\\\n        let ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        ruleList = ruleList.filter(item => item.isEnabled);\\\\n        let len = ruleList.length;\\\\n        let replacePattern = [\\\\\\\"replace\\\\\\\", \\\\\\\"replaceAll\\\\\\\"];\\\\n        let flag = File.fileRule(entirePathto, entirePath, (javaString) => {\\\\n            for (let i = 0; i < len; i++) {\\\\n                let replaceRule = ruleList[i];\\\\n                let replace = replacePattern[0 + replaceRule.isRegex];\\\\n                javaString = javaString[replace](replaceRule.pattern, replaceRule.replacement);\\\\n            }\\\\n            return javaString.getBytes();\\\\n        });\\\\n        if (!flag) {\\\\n            hideLoading();\\\\n            return \\\\\\\"toast://合并失败\\\\\\\";\\\\n        }\\\\n\\\\n    }\\\\n    hideLoading();\\\\n    return \\\\\\\"toast://合并完成\\\\\\\";\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"合并小说\\\\\\\",\\\\n    url: $(\\\\\\\"确定合并?\\\\\\\\n会覆盖已有TXT\\\\\\\").confirm(txt, MY_PARAMS, bookInfo.isReplace),\\\\n    col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: [\\\\\\\"☐分页\\\\\\\", \\\\\\\"☑分页\\\\\\\"][mode2],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((mode2) => {\\\\n        putMyVar(\\\\\\\".mode2\\\\\\\", mode2 === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, mode2),\\\\n    col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: [\\\\\\\"☐净化\\\\\\\", \\\\\\\"☑净化\\\\\\\"][0 + bookInfo.isReplace],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReplace, path) => {\\\\n        const bookInfo = JSON.parse(request(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n        bookInfo.isReplace = !isReplace;\\\\n        writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, bookInfo.isReplace, path),\\\\n    col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title:'外部查看',\\\\n    url:$('#noLoading#').lazyRule((path,isReplace)=>{\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n    const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n    const Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n    let entirePath = path.replace(Config.novelPath, Config.novelFullPath) + \\\\\\\".txt\\\\\\\";\\\\n    let entirePathto = isReplace ? entirePath + \\\\\\\".tmp\\\\\\\" : entirePath;\\\\n    //log(entirePathto);\\\\n    if (fileExist(\\\\\\\"file://\\\\\\\" + entirePath)) {\\\\n        toast(\\\\\\\"调用第三方应用打开文件\\\\\\\");\\\\n        return 'openFile://file://'+entirePath\\\\n    }else{\\\\n        return 'toast://本地暂无可供外部打开的txt文件，请先合并小说！'\\\\n    }\\\\n    },path,bookInfo.isReplace),\\\\n    col_type:'scroll_button'\\\\n});\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\n\\\\nlet mhlist = File.getFilePath(path, \\\\\\\"file\\\\\\\", \\\\\\\".txt\\\\\\\");\\\\nmhlist.sort((a, b) => {\\\\n    a = (a.name.match(/\\\\\\\\d+/) || [])[0] || 0;\\\\n    b = (b.name.match(/\\\\\\\\d+/) || [])[0] || 0;\\\\n    return a - b;\\\\n});\\\\nlet chapterList = [];\\\\nlet chapterCount = mhlist.length;\\\\n\\\\nif (mode2 === \\\\\\\"1\\\\\\\") {\\\\n    let mhlistChunk = Tool.chunk(mhlist, Config.viewPageSize);\\\\n    let viewPageCount = mhlistChunk.length;\\\\n    let defPage = (viewPageCount - 1 < bookInfo.foot ? 0 : bookInfo.foot) || 0;\\\\n    let pageNum = Number(getMyVar(\\\\\\\".pageNum\\\\\\\", \\\\\\\"\\\\\\\" + defPage));\\\\n    chapterList = mhlistChunk[pageNum] || [];\\\\n    layout.push({\\\\n        title: \\\\\\\"““””\\\\\\\" + \\\\\\\"章节 \\\\\\\".big() + (\\\\\\\"本页:\\\\\\\" + chapterList.length + \\\\\\\" 共有:\\\\\\\" + chapterCount + \\\\\\\"章 当前:\\\\\\\" + (pageNum + 1) + \\\\\\\"/\\\\\\\" + viewPageCount).small(),\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReverse) => {\\\\n            putMyVar(\\\\\\\".isReverse\\\\\\\", isReverse === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n            refreshPage(true);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, isReverse),\\\\n        col_type: \\\\\\\"text_1\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"跳集\\\\\\\",\\\\n        url: $(chapterCount, \\\\\\\"输入跳转章节 1-\\\\\\\" + chapterCount).input((chapterCount, pageNum, viewPageSize, path) => {\\\\n            let inputNum = Number(input);\\\\n            if (Number.isNaN(inputNum) || inputNum < 0 || inputNum > chapterCount) {\\\\n                return \\\\\\\"toast://请输入正确范围内的数字\\\\\\\";\\\\n            }\\\\n            inputNum = Math.floor((inputNum + viewPageSize) / viewPageSize) - 1;\\\\n            if (pageNum === inputNum) return \\\\\\\"toast://正在当前页面\\\\\\\";\\\\n            putMyVar(\\\\\\\".pageNum\\\\\\\", \\\\\\\"\\\\\\\" + inputNum);\\\\n            const bookInfo = JSON.parse(request(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n            bookInfo.foot = inputNum;\\\\n            writeFile(\\\\\\\"file://\\\\\\\" + path, JSON.stringify(bookInfo));\\\\n            refreshPage(false);\\\\n        }, chapterCount, pageNum, Config.viewPageSize, path),\\\\n        col_type: \\\\\\\"text_5\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"跳页\\\\\\\",\\\\n        url: $(pageNum + 1, \\\\\\\"跳转页数 1-\\\\\\\" + viewPageCount).input((viewPageCount, pageNum, path) => {\\\\n            let inputNum = Number(input) - 1;\\\\n            if (Number.isNaN(inputNum) || inputNum < 0 || inputNum > viewPageCount - 1) {\\\\n                return \\\\\\\"toast://请输入正确范围内的数字\\\\\\\";\\\\n            }\\\\n            if (pageNum === inputNum) return \\\\\\\"toast://正在当前页面\\\\\\\";\\\\n            putMyVar(\\\\\\\".pageNum\\\\\\\", \\\\\\\"\\\\\\\" + inputNum);\\\\n            const bookInfo = JSON.parse(request(path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n            bookInfo.foot = inputNum;\\\\n            writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n            refreshPage(false);\\\\n        }, viewPageCount, pageNum, path),\\\\n        col_type: \\\\\\\"text_5\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"上一页\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((pageNum, path) => {\\\\n            let inputNum = pageNum - 1;\\\\n            if (inputNum < 0) {\\\\n                return \\\\\\\"toast://已经是第一页了\\\\\\\";\\\\n            }\\\\n            putMyVar(\\\\\\\".pageNum\\\\\\\", \\\\\\\"\\\\\\\" + inputNum);\\\\n            const bookInfo = JSON.parse(request(path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n            bookInfo.foot = inputNum;\\\\n            log(bookInfo.foot);\\\\n            writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, pageNum, path),\\\\n        col_type: \\\\\\\"text_5\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"下一页\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((viewPageCount, pageNum, path) => {\\\\n            let inputNum = pageNum + 1;\\\\n            if (inputNum > viewPageCount - 1) {\\\\n                return \\\\\\\"toast://已经是最后一页了\\\\\\\";\\\\n            }\\\\n            putMyVar(\\\\\\\".pageNum\\\\\\\", \\\\\\\"\\\\\\\" + inputNum);\\\\n            const bookInfo = JSON.parse(request(path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n            bookInfo.foot = inputNum;\\\\n            writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, viewPageCount, pageNum, path),\\\\n        col_type: \\\\\\\"text_5\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"末页\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((viewPageCount, pageNum, path) => {\\\\n            let inputNum = viewPageCount - 1;\\\\n            if (pageNum === inputNum || inputNum === -1) {\\\\n                return \\\\\\\"toast://已经是最后一页了\\\\\\\";\\\\n            }\\\\n            putMyVar(\\\\\\\".pageNum\\\\\\\", \\\\\\\"\\\\\\\" + inputNum);\\\\n            const bookInfo = JSON.parse(request(path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n            bookInfo.foot = inputNum;\\\\n            writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, viewPageCount, pageNum, path),\\\\n        col_type: \\\\\\\"text_5\\\\\\\"\\\\n    });\\\\n} else {\\\\n    chapterList = mhlist;\\\\n    layout.push({\\\\n        title: \\\\\\\"““””\\\\\\\" + \\\\\\\"章节 \\\\\\\".big() + (\\\\\\\"共有:\\\\\\\" + chapterCount + \\\\\\\"章\\\\\\\").small(),\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReverse) => {\\\\n            putMyVar(\\\\\\\".isReverse\\\\\\\", isReverse === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n            refreshPage(true);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, isReverse),\\\\n        col_type: \\\\\\\"text_1\\\\\\\"\\\\n    });\\\\n}\\\\nlet array = [];\\\\nif (mode === \\\\\\\"0\\\\\\\") {\\\\n    for (let item of chapterList) {\\\\n        let name = getTitle(item.name);\\\\n        array.push({\\\\n            title: name,\\\\n            url: \\\\\\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\\\\\",\\\\n            extra: {\\\\n                path: item.path,\\\\n                title: name,\\\\n                isReplace: bookInfo.isReplace\\\\n            },\\\\n            col_type: Config.def_View_Style\\\\n        });\\\\n    }\\\\n} else {\\\\n    for (let item of chapterList) {\\\\n        let name = getTitle(item.name);\\\\n        array.push({\\\\n            title: name,\\\\n            url: $(\\\\\\\"确认删除[\\\\\\\" + name + \\\\\\\"]？\\\\\\\").confirm((path) => {\\\\n                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                if (File.deleteFlies(path)) {\\\\n                    refreshPage(true);\\\\n                    return \\\\\\\"toast://删除成功\\\\\\\";\\\\n                } else {\\\\n                    return \\\\\\\"toast://删除失败\\\\\\\";\\\\n                }\\\\n            }, item.path),\\\\n            col_type: Config.def_View_Style\\\\n        });\\\\n    }\\\\n}\\\\nif (isReverse === \\\\\\\"1\\\\\\\") {\\\\n    array.reverse();\\\\n}\\\\nlayout.push.apply(layout, array);\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.小说正文阅读\\\",\\\"path\\\":\\\"NovelMainBody\\\",\\\"rule\\\":\\\"js:\\\\nvar layout = [];\\\\nlet content = request(\\\\\\\"file://\\\\\\\" + MY_PARAMS.path);\\\\n//content = content.replace(/\\\\\\\\n|\\\\\\\\r/g, \\\\\\\"<br>\\\\\\\").replace(/(&nbsp;)+/g,\\\\\\\" \\\\\\\");\\\\nif (MY_PARAMS.isReplace) {\\\\n    let javaString = java.lang.String(content);\\\\n    let ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let replacePattern = [\\\\\\\"replace\\\\\\\", \\\\\\\"replaceAll\\\\\\\"];\\\\n    for (let i = 0, len = ruleList.length; i < len; i++) {\\\\n        let replaceRule = ruleList[i];\\\\n        if (!replaceRule.isEnabled) continue;\\\\n        let replace = replacePattern[0 + replaceRule.isRegex];\\\\n        javaString = javaString[replace](replaceRule.pattern, replaceRule.replacement);\\\\n    }\\\\n    content = String(javaString);\\\\n}\\\\ncontent = \\\\\\\"　　\\\\\\\" + content.replace(/^\\\\\\\\s+|\\\\\\\\s+$/gm, \\\\\\\"\\\\\\\").split(/\\\\\\\\n+/).join(\\\\\\\"<br>　　\\\\\\\");\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    title: (\\\\\\\"<strong>\\\\\\\" + MY_PARAMS.title + \\\\\\\"</strong>\\\\\\\").big(),\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: content,\\\\n    col_type: 'rich_text',\\\\n    extra: {\\\\n        textSize: 18,\\\\n        click: true\\\\n    }\\\\n});\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.小说全集查看\\\",\\\"path\\\":\\\"NovelCollected.view\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\nlet rulelDir = File.getFilePath(Config.novelFullPath, \\\\\\\"dir\\\\\\\");\\\\n\\\\nlet layout = [];\\\\n\\\\nfunction operation(path) {\\\\n    switch (input) {\\\\n        case \\\\\\\"分享\\\\\\\":\\\\n            return \\\\\\\"share://\\\\\\\" + path;\\\\n            break;\\\\n        case \\\\\\\"删除\\\\\\\":\\\\n            const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n            if (File.deleteFlies(path)) {\\\\n                refreshPage();\\\\n                return \\\\\\\"toast://删除成功\\\\\\\";\\\\n            } else {\\\\n                return \\\\\\\"toast://删除失败\\\\\\\";\\\\n            }\\\\n            break;\\\\n        case \\\\\\\"预览\\\\\\\":\\\\n            return \\\\\\\"editFile://file://\\\\\\\" + path;\\\\n        case \\\\\\\"外部查看\\\\\\\":\\\\n            return \\\\\\\"openFile://file://\\\\\\\" + path;\\\\n            break;\\\\n    }\\\\n}\\\\nfor (let rulePaths of rulelDir) {\\\\n    let novels = File.getFilePath(rulePaths.path, \\\\\\\"file\\\\\\\");\\\\n    for (let novel of novels) {\\\\n        layout.push({\\\\n            title: novel.name,\\\\n            url: $([\\\\\\\"分享\\\\\\\", \\\\\\\"删除\\\\\\\", \\\\\\\"预览\\\\\\\",\\\\\\\"外部查看\\\\\\\"], 1).select(operation, novel.path),\\\\n            desc: \\\\\\\"来源：\\\\\\\" + rulePaths.name,\\\\n            col_type: \\\\\\\"text_1\\\\\\\"\\\\n        });\\\\n    }\\\\n}\\\\nif (layout.length === 0) {\\\\n    layout.push({\\\\n        title: '<h1 style=\\\\\\\"text-align: center;\\\\\\\">啥都没有耶</h1>',\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    });\\\\n}\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.更多设置\\\",\\\"path\\\":\\\"Setting/More.view\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nconst settingType = MY_PARAMS.settingType || getParam(\\\\\\\"settingType\\\\\\\");\\\\n\\\\nlet layout = [];\\\\n\\\\nswitch (settingType) {\\\\n    case \\\\\\\"cache\\\\\\\":\\\\n        setPageTitle(\\\\\\\"清除缓存|设置\\\\\\\");\\\\n        const knownList = new Map([\\\\n            [File.getName(Config.novelPath), \\\\\\\"#管理器#小说缓存目录[不建议清除]\\\\\\\"],\\\\n            [File.getName(Config.comicPath), \\\\\\\"#管理器#漫画缓存目录[不建议清除]\\\\\\\"],\\\\n            [File.getName(Config.novelFullPath), \\\\\\\"#管理器#小说合并目录[可以清除]\\\\\\\"],\\\\n            [\\\\\\\"dr章节缓存\\\\\\\", \\\\\\\"道长模板临时缓存[建议清除]\\\\\\\"]\\\\n        ]);\\\\n\\\\n        let cacheDir = File.getFilePath(Config.homePath, \\\\\\\"dir\\\\\\\");\\\\n\\\\n        function cleanCache(path) {\\\\n            const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n            if (File.deleteFlies(path)) {\\\\n                refreshPage(false);\\\\n                return \\\\\\\"toast://清除完成\\\\\\\";\\\\n            } else {\\\\n                return \\\\\\\"toast://清除失败\\\\\\\";\\\\n            }\\\\n        }\\\\n        for (let cache of cacheDir) {\\\\n            layout.push({\\\\n                title: cache.name,\\\\n                desc: \\\\\\\"大小：\\\\\\\" + File.getFileSize(cache.path) + \\\\\\\"\\\\\\\\n描述：\\\\\\\" + knownList.get(cache.name) || \\\\\\\"未知目录[风险未知]\\\\\\\",\\\\n                col_type: \\\\\\\"text_1\\\\\\\",\\\\n                url: $(\\\\\\\"确认清除 \\\\\\\" + cache.name + \\\\\\\" ?\\\\\\\").confirm(cleanCache, cache.path)\\\\n            });\\\\n        }\\\\n        layout.push({\\\\n            col_type: \\\\\\\"line_blank\\\\\\\"\\\\n        });\\\\n        layout.push({\\\\n            title: \\\\\\\"全部清除(\\\\\\\" + File.getFileSize(Config.homePath) + \\\\\\\")\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            url: $(\\\\\\\"确认清除全部缓存数据?\\\\\\\").confirm(cleanCache, Config.homePath)\\\\n        });\\\\n        break;\\\\n    case \\\\\\\"defaultPic\\\\\\\":\\\\n        setPageTitle(\\\\\\\"默认封面|设置\\\\\\\");\\\\n\\\\n        function setDefaultPic(url) {\\\\n            let Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n            Config.def_Pic = url;\\\\n            saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config));\\\\n            back();\\\\n            return \\\\\\\"toast://修改成功\\\\\\\";\\\\n        }\\\\n        for (let i = 1; i <= 4; i++) {\\\\n            layout.push({\\\\n                title: \\\\\\\"图片\\\\\\\" + i,\\\\n                col_type: \\\\\\\"movie_3\\\\\\\",\\\\n                pic_url: \\\\\\\"hiker://images/home_pic\\\\\\\" + i,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(setDefaultPic, \\\\\\\"hiker://images/home_pic\\\\\\\" + i)\\\\n            });\\\\n        }\\\\n        break;\\\\n    case \\\\\\\"replaceRule\\\\\\\":\\\\n        setPageTitle(\\\\\\\"替换规则|设置\\\\\\\");\\\\n        let ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        let id = \\\\\\\"#\\\\\\\" + new Date().getTime();\\\\n\\\\n        layout.push({\\\\n            title: \\\\\\\"新建替换\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/editReplaceRule.view#noRecordHistory##noHistory##noRefresh#?isNew=true\\\\\\\",\\\\n            col_type: \\\\\\\"text_3\\\\\\\"\\\\n        });\\\\n        layout.push({\\\\n            title: \\\\\\\"导出规则\\\\\\\",\\\\n            url: $(\\\\\\\"确认导出\\\\\\\" + ruleList.length + \\\\\\\"条规则？\\\\\\\\n({homePtah}/replaceRule.json)\\\\\\\").confirm((num) => {\\\\n                const Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n                let savePta = Config.homePath + \\\\\\\"/replaceRule.json\\\\\\\";\\\\n                writeFile(savePta, readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n                log(\\\\\\\"\\\\\\\\n路径：\\\\\\\" + savePta + \\\\\\\"\\\\\\\\n导出规则 \\\\\\\" + num + \\\\\\\" 条\\\\\\\");\\\\n                return \\\\\\\"share://\\\\\\\" + savePta;\\\\n            }, ruleList.length),\\\\n            col_type: \\\\\\\"text_3\\\\\\\"\\\\n        });\\\\n        layout.push({\\\\n            title: \\\\\\\"导入规则\\\\\\\",\\\\n            url: $(\\\\\\\"\\\\\\\", \\\\\\\"输入规则文件路径(*.json)\\\\\\\", \\\\\\\"规则导入\\\\\\\").input(() => {\\\\n                input = input.startsWith(\\\\\\\"file://\\\\\\\") ? input : \\\\\\\"file://\\\\\\\" + input\\\\n                let ruleText = request(input);\\\\n                if (!ruleText) return \\\\\\\"toast://获取文件为空\\\\\\\";\\\\n                try {\\\\n                    let newRuleList = JSON.parse(ruleText);\\\\n                    let ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n                    let newCount = 0,\\\\n                        updateCount = 0;\\\\n                    for (let i in newRuleList) {\\\\n                        let newRule = newRuleList[i];\\\\n                        let id = newRule.id;\\\\n                        newRule.id = id || new Date().getTime();\\\\n                        let idIndex = ruleList.findIndex(rule => rule.id === id);\\\\n                        if (idIndex > -1) {\\\\n                            updateCount++;\\\\n                            ruleList.splice(idIndex, 1, newRule);\\\\n                        } else {\\\\n                            newCount++;\\\\n                            ruleList.push(newRule);\\\\n                        }\\\\n                    }\\\\n                    saveFile(\\\\\\\"replaceRule.json\\\\\\\", JSON.stringify(ruleList));\\\\n                    refreshPage();\\\\n                    log(\\\\\\\"\\\\\\\\n路径：\\\\\\\" + input + \\\\\\\"\\\\\\\\n总规则数：\\\\\\\" + newRuleList.length + \\\\\\\"\\\\\\\\n更新规则 \\\\\\\" + updateCount + \\\\\\\" 条\\\\\\\\t新增规则 \\\\\\\" + newCount + \\\\\\\" 条\\\\\\\");\\\\n                    return \\\\\\\"toast://导入成功\\\\\\\";\\\\n                } catch (e) {\\\\n                    log(e.toString());\\\\n                    return \\\\\\\"toast://导入失败\\\\\\\";\\\\n                }\\\\n            }),\\\\n            col_type: \\\\\\\"text_3\\\\\\\"\\\\n        });\\\\n        layout.push({\\\\n            col_type: \\\\\\\"line_blank\\\\\\\"\\\\n        });\\\\n        for (let i = 0, len = ruleList.length; i < len; i++) {\\\\n            let replaceRule = ruleList[i];\\\\n            layout.push({\\\\n                title: (replaceRule.isEnabled ? \\\\\\\"●\\\\\\\" : \\\\\\\"○\\\\\\\") + replaceRule.name,\\\\n                col_type: \\\\\\\"text_1\\\\\\\",\\\\n                url: \\\\\\\"hiker://empty\\\\\\\",\\\\n                extra: {\\\\n                    id: id + i,\\\\n                    lineVisible: false\\\\n                }\\\\n            });\\\\n            layout.push({\\\\n                title: \\\\\\\"删除\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((id, index) => {\\\\n                    var ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n                    ruleList.splice(index, 1);\\\\n                    saveFile(\\\\\\\"replaceRule.json\\\\\\\", JSON.stringify(ruleList));\\\\n                    deleteItem(id + index);\\\\n                    deleteItem(id +\\\\\\\"#\\\\\\\" +index);\\\\n                    deleteItem(id +\\\\\\\"$\\\\\\\" +index);\\\\n                    deleteItem(id +\\\\\\\"@\\\\\\\" +index);\\\\n                    toast(\\\\\\\"删除成功\\\\\\\");\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }, id, i),\\\\n                extra:{\\\\n                    id: id+\\\\\\\"#\\\\\\\"+i\\\\n                },\\\\n                col_type: \\\\\\\"text_3\\\\\\\"\\\\n            });\\\\n            layout.push({\\\\n                title: \\\\\\\"编辑\\\\\\\",\\\\n                url: \\\\\\\"hiker://page/editReplaceRule.view#noRecordHistory##noHistory##noRefresh#?index=\\\\\\\" + i,\\\\n                col_type: \\\\\\\"text_3\\\\\\\",\\\\n                extra:{\\\\n                    id: id+\\\\\\\"$\\\\\\\"+i\\\\n                }\\\\n            });\\\\n            layout.push({\\\\n                title: \\\\\\\"开启/关闭\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((id, index, title) => {\\\\n                    var ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n                    let isEnabled = ruleList[index].isEnabled;\\\\n                    ruleList[index].isEnabled = !isEnabled;\\\\n                    updateItem({\\\\n                        extra: {\\\\n                            id: id + index,\\\\n                            lineVisible: false\\\\n                        },\\\\n                        title: (isEnabled ? \\\\\\\"○\\\\\\\" : \\\\\\\"●\\\\\\\") + title\\\\n                    });\\\\n                    saveFile(\\\\\\\"replaceRule.json\\\\\\\", JSON.stringify(ruleList));\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }, id, i, replaceRule.name),\\\\n                col_type: \\\\\\\"text_3\\\\\\\",\\\\n                extra:{\\\\n                    id: id+\\\\\\\"@\\\\\\\"+i\\\\n                }\\\\n            });\\\\n            layout.push({\\\\n                col_type: \\\\\\\"line\\\\\\\"\\\\n            });\\\\n        }\\\\n\\\\n        break;\\\\n}\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.编辑替换规则\\\",\\\"path\\\":\\\"editReplaceRule.view\\\",\\\"rule\\\":\\\"js:\\\\nconst isNew = MY_PARAMS.isNew || getParam(\\\\\\\"isNew\\\\\\\");\\\\nconst index = MY_PARAMS.index || Number(getParam(\\\\\\\"index\\\\\\\"));\\\\nlet layout = [];\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\".editReplaceRule.name\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.first\\\\\\\");\\\\n    //clearMyVar(\\\\\\\".editReplaceRule.scope\\\\\\\");\\\\n}));\\\\nlet ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\nlet id = \\\\\\\"#\\\\\\\" + new Date().getTime();\\\\n//let replaceRule = isNew == \\\\\\\"true\\\\\\\"?{}:ruleList[index];\\\\nif (isNew == \\\\\\\"true\\\\\\\") {\\\\n    replaceRule = {\\\\n        id: new Date().getTime(),\\\\n        isEnabled: true,\\\\n        isRegex: false,\\\\n    }\\\\n} else {\\\\n    replaceRule = ruleList[index];\\\\n}\\\\n//首次初始化\\\\nif(getMyVar(\\\\\\\".editReplaceRule.first\\\\\\\",\\\\\\\"\\\\\\\")==\\\\\\\"\\\\\\\"){\\\\n    putMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\", \\\\\\\"\\\\\\\" + replaceRule.isRegex);\\\\n    putMyVar(\\\\\\\".editReplaceRule.first\\\\\\\",\\\\\\\"1\\\\\\\");\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"拷贝\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n        let att = [\\\\\\\"name\\\\\\\", \\\\\\\"isRegex\\\\\\\", \\\\\\\"pattern\\\\\\\", \\\\\\\"replacement\\\\\\\"];\\\\n        let json = {};\\\\n        att.forEach(key => {\\\\n            let value = getMyVar(\\\\\\\".editReplaceRule.\\\\\\\" + key, \\\\\\\"\\\\\\\");\\\\n            if (key === \\\\\\\"isRegex\\\\\\\") {\\\\n                value = value === \\\\\\\"true\\\\\\\" ? true : false;\\\\n            }\\\\n            json[key] = value;\\\\n        });\\\\n        copy(JSON.stringify(json));\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"粘贴\\\\\\\",\\\\n    url: $(\\\\\\\"{{clipboard}}\\\\\\\").input(() => {\\\\n        try {\\\\n            let json = JSON.parse(input);\\\\n            if (Array.isArray(json) || json.pattern == undefined) return;\\\\n            let att = [\\\\\\\"name\\\\\\\", \\\\\\\"isRegex\\\\\\\", \\\\\\\"pattern\\\\\\\", \\\\\\\"replacement\\\\\\\"];\\\\n            att.forEach(key => {\\\\n                putMyVar(\\\\\\\".editReplaceRule.\\\\\\\" + key, String(json[key]));\\\\n            });\\\\n            refreshPage(false);\\\\n        } catch (e) {\\\\n            log(e.toString());\\\\n        }\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换规则名称\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        defaultValue: getMyVar(\\\\\\\".editReplaceRule.name\\\\\\\", replaceRule.name),\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.name\\\\\\\",input);'\\\\n    }\\\\n});\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换规则\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height: -1,\\\\n        defaultValue: getMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\", replaceRule.pattern),\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\", input);'\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"是否使用正则表达式：\\\\\\\" + getMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\"),\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((id) => {\\\\n        let isRegex = getMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\") === \\\\\\\"true\\\\\\\" ? false : true;\\\\n        updateItem({\\\\n            extra: {\\\\n                id: id\\\\n            },\\\\n            title: \\\\\\\"是否使用正则表达式：\\\\\\\" + isRegex\\\\n        });\\\\n        putMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\", \\\\\\\"\\\\\\\" + isRegex);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, id),\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        id: id\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换为\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height: -1,\\\\n        defaultValue: getMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\", replaceRule.replacement),\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\",input);'\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"保存\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((replaceRule, isNew, index) => {\\\\n        let pattern = getMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\", \\\\\\\"\\\\\\\");\\\\n        if (!pattern) {\\\\n            return \\\\\\\"toast://替换规则不能为空\\\\\\\";\\\\n        }\\\\n        Object.assign(replaceRule, {\\\\n            name: getMyVar(\\\\\\\".editReplaceRule.name\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n            isRegex: getMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\") === \\\\\\\"true\\\\\\\" ? true : false,\\\\n            pattern: pattern,\\\\n            replacement: getMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\", \\\\\\\"\\\\\\\")\\\\n        });\\\\n        let ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        if (isNew == \\\\\\\"true\\\\\\\") {\\\\n            ruleList.push(replaceRule);\\\\n        } else {\\\\n            ruleList.splice(index, 1, replaceRule);\\\\n        }\\\\n        saveFile(\\\\\\\"replaceRule.json\\\\\\\", JSON.stringify(ruleList));\\\\n        back();\\\\n        return \\\\\\\"toast://保存成功\\\\\\\";\\\\n    }, replaceRule, isNew, index),\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n});\\\\n\\\\n/*\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换范围\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height: -1,\\\\n        defaultValue: \\\\\\\"\\\\\\\",\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.scope\\\\\\\",input);'\\\\n    }\\\\n});\\\\n\\\\n*/\\\\nsetResult(layout);\\\"}]\"}","title":"选择器|信息素说我们不可能"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!