API tools faq
paste
xiaomianao666

小程序：本地资源管理

xiaomianao666
May 26th, 2023
90
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 216.01 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@本地资源管理@{"last_chapter_rule":"","title":"本地资源管理","author":"@LoyDgIk","url":"hiker://empty","version":90,"col_type":"movie_3_marquee","class_name":"","type":"tool","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\n\nif (!getItem(\":startUse\", false)) {\n    toast(\":-)初次见面，请多关照\");\n    confirm({\n        title: \"使用须知\",\n        content: \"1.普通用户：本程序只提供本地阅读服务，不提供网络内容。\\n\\n2.开发者：提供多线程下载支持。\\n\\n3.如何获取内容?\\n通过「聚漫」「道长合集」等第三方小程序下载。\",\n        confirm: \"setItem(':startUse','1');refreshPage();'toast://感谢您的理解'\",\n        cancel: \"'toast://很遗憾，不能为您服务。\\\\n长按标题可删除。'\"\n    });\n    setResult([]);\n} else if (MY_RULE.title !== \"本地资源管理\") {\n    confirm({\n        title: \"警告⚠\",\n        content: \"不能改名哦！\",\n        confirm: $.toString(() => {\n            MY_RULE.title = \"本地资源管理\";\n            toast(\"已帮你改回原名，请重新导入\");\n            return \"rule://\" + base64Encode(\"海阔视界￥home_rule￥\" + JSON.stringify(MY_RULE));\n        }),\n        cancel: \"'toast://很遗憾，不能为您服务。\\\\n长按标题可删除。'\"\n    });\n    setResult([]);\n} else {\n    $.require(\"hiker://page/Main.view\");\n}","search_url":"","group":"①推荐","searchFind":"","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","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 deleteFiles(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\\n//copy单个文件\\nfunction copyFile(source, target, isCover) {\\n    let sourcePath = Paths.get(source);\\n    let targetPath = Paths.get(target);\\n    let isExist = Files.exists(targetPath);\\n    if (Files.isDirectory(sourcePath) || (isExist && !isCover) || (isExist && Files.isDirectory(targetPath))) {\\n        return false;\\n    }\\n    try {\\n        if (!isExist) {\\n            Files.createDirectories(targetPath.getParent());\\n        }\\n        if (isCover === true) {\\n            Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES);\\n        } else {\\n            Files.copy(sourcePath, targetPath, StandardCopyOption.COPY_ATTRIBUTES);\\n        }\\n    } catch (e) {\\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                lastModified: Number(array[i].lastModified()),\\n            });\\n        }\\n    }\\n    if (expand) {\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\n    }\\n    return pathList;\\n}\\n\\nfunction getFiles(path, type, expand) {\\n    let types = {\\n        \\\"file\\\": \\\"isFile\\\",\\n        \\\"dir\\\": \\\"isDirectory\\\"\\n    };\\n    let fileType = types[type];\\n    let file = new File(path);\\n    let array = file.listFiles() || [];\\n    let fileList = [];\\n    for (let i = 0; i < array.length; i++) {\\n        let file = array[i];\\n        if ((!fileType || file[fileType]()) && (!expand || file.getName().endsWith(expand))) {\\n            fileList.push(file);\\n        }\\n    }\\n    return fileList;\\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 (!toFile.delete()) {\\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 (!deleteFiles(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 size.toFixed(2).replace(/(\\\\.00)$/, \\\"\\\") + 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\\nfunction readFile(path) {\\n    try {\\n        let paths = Paths.get(path);\\n        if (!Files.exists(paths)) return \\\"\\\";\\n        return String(new javaString(Files.readAllBytes(paths)));\\n    } catch {\\n        return \\\"\\\";\\n    }\\n}\\n$.exports = {\\n    getFileTime: (path) => getFileTime(path),\\n    getFilePath: (path, type, expand) => getFilePath(path, type, expand),\\n    deleteFiles: (path) => deleteFiles(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    copyFile: (source, target, isCover) => copyFile(source, target, isCover),\\n    readFile: (path) => readFile(path),\\n    getFiles: (path, type, expand) => getFiles(path, type, expand),\\n    getTotalSizeOfFilesInDir:(file)=>getTotalSizeOfFilesInDir(file)\\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    decode: undefined,\\n    type: \\\"comic\\\",\\n    comicScheme: \\\"1\\\"\\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\\nviewConfig.info.bookName=Tool.textShield(viewConfig.info.bookName);\\nviewConfig.info.ruleName=Tool.textShield(viewConfig.info.ruleName);\\n\\nconst def_DoVi_Style = Config.def_DoVi_Style;\\nconst MY_ID = info.ruleName + \\\"//\\\" + info.bookName;\\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    item.title=Tool.textShield(item.title);\\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, i, MY_ID);\\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            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在下载哦~\\\";\\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            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在下载哦~\\\";\\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\\n        if (is_download) {\\n            completed.push(item.CID);\\n            if(tagFilter !== \\\"1\\\"){\\n                chapterTeam.push(comFun(item.CID, item));\\n            }\\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            if(info.type===\\\"comic\\\"&&info.comicScheme===\\\"1\\\"){\\n                download=download.b;\\n            }else{\\n                download=download.a;\\n            }\\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\\n$.exports.a = function(chapterTeam, info, MY_ID) {\\n    if (chapterTeam.length === 0) {\\n        return \\\"toast://空的下载队列\\\";\\n    }\\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\\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 task(taskParam) {\\n        let result = $.require(\\\"hiker://page/Batch.exe.js\\\")(taskParam);\\n        return result;\\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\\\") + \\\" \\\" + String((ratio * 100)).slice(0, 5) + \\\"%\\\",\\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            count = taskCount;\\n        }\\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            return \\\"break\\\";\\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};\\n\\n$.exports.b = function comic(chapterTeam, info, MY_ID) {\\n    if (chapterTeam.length === 0) {\\n        return \\\"toast://空的下载队列\\\";\\n    }\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n\\n    let logNum = Config.logNum;\\n    let logCount = 0;\\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 task(taskParam) {\\n        const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n        for (let i = 0; i < 10; i++) {\\n            try {\\n                let pic = Tool.hikerPic(taskParam.url);\\n                Tool.picDownload(pic[0], taskParam.chapterPath + (taskParam.i + 1) + \\\".jpg\\\", pic[1], taskParam.decode);\\n                if (getMyVar(taskParam.MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n                    return -1;\\n                }\\n                errorNum = 0;\\n                break;\\n            } catch (e) {\\n                if (i === 9) {\\n                    throw e;\\n                }\\n            }\\n        }\\n        return taskParam.CID;\\n    }\\n    let count = 0;\\n    let totalCount = 0;\\n    let successCID = [];\\n\\n    function listener(param, id, error, result) {\\n        try {\\n            totalCount++;\\n\\n            if (error != null) {\\n                putLog(\\\"[listener]下载失败：\\\" + id + \\\"<ERROR@ \\\" + error + \\\">\\\");\\n            } else if (result === -1) {\\n                putLog(\\\"[listener]已停止：\\\" + id);\\n                totalCount = param.pivCount;\\n            } else {\\n                count++;\\n                let ratio = ((count / param.pivCount)).toFixed(4);\\n                let stripCount = Math.ceil(ratio * 10);\\n                if (param.pivCount === totalCount && totalCount === count) {\\n                    successCID.push(param.CID);\\n                }\\n                updateItem({\\n                    title: \\\"下载进度：\\\" + (successCID.length) + \\\"/\\\" + param.total,\\n                    desc: \\\"““””\\\" + \\\"▇\\\".repeat(stripCount).fontcolor(\\\"#ffac2d\\\") + \\\"▇\\\".repeat(10 - stripCount).fontcolor(\\\"#e5e1e4\\\") + \\\" \\\" + String((ratio * 100)).slice(0, 5) + \\\"%\\\",\\n                    extra: {\\n                        id: MY_ID + \\\"||下载进度\\\"\\n                    }\\n                });\\n                //putLog(\\\"[listener]已完成下载：\\\" + id);\\n            }\\n            if (totalCount !== param.pivCount) return;\\n            if (totalCount === count) {\\n                File.renameFile(param.chapterPath, param.CID + \\\"$A$\\\" + Tool.textShield(param.title));\\n            }\\n            totalCount = count = 0;\\n            return \\\"break\\\";\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n    let taskTeam = [];\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + Tool.textShield(info.bookName) + \\\"/\\\";\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1], info.decode);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n\\n    for (let k = 0; k < chapterTeam.length; k++) {\\n        let item = chapterTeam[k];\\n        let order = k;\\n        let chapterPath = mainPath + item.CID + \\\"$B$\\\" + Tool.textShield(item.title) + \\\"/\\\";\\n        let picList = [];\\n        try {\\n            let getPicList = new Function(\\\"input\\\", \\\"url\\\", \\\"return\\\" + info.parseCode);\\n            picList = getPicList(item.url, item.url);\\n            if (typeof picList === \\\"string\\\") {\\n                picList = picList.replace(\\\"pics://\\\", \\\"\\\").split(\\\"&&\\\");\\n            }\\n        } catch (e) {\\n            putLog(\\\"<漫画图片解析错误> \\\" + e.message);\\n            continue;\\n        }\\n        if (picList.length === 0) {\\n            putLog(\\\"<漫画图片解析错误：图片链接返回为空>\\\");\\n            continue;\\n        }\\n        picList = picList.filter(p => p);\\n        var taskTeam = picList.map((url, i) => ({\\n            func: task,\\n            id: i,\\n            param: {\\n                url: url,\\n                i: i,\\n                chapterPath: chapterPath,\\n                MY_ID: MY_ID,\\n                decode: info.decode\\n            }\\n        }));\\n        be(taskTeam, {\\n            func: listener,\\n            param: {\\n                pivCount: picList.length,\\n                total: chapterTeam.length,\\n                order: order,\\n                CID: item.CID,\\n                title: item.title,\\n                chapterPath: chapterPath\\n            }\\n        });\\n        if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n            break;\\n        }\\n    }\\n\\n    let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n    java.lang.Thread.sleep(40);\\n    //let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let failTeam = chapterTeam.filter(v => !successCID.includes(v.CID));\\n    let failName = failTeam.map(item => item.title);\\n    let batchTeam = failTeam.map(item => item.CID);\\n\\n    if (failTeam.length > 0 && status !== \\\"1\\\") {\\n        putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\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 + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\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    return \\\"hiker://empty\\\";\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.批量主程序\",\"path\":\"Batch.exe.js\",\"rule\":\"const Mian = $.require(\\\"mainDownload\\\");\\nfunction comic(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    return Mian.comic(chapterItem, info, chapterItem.CID, MY_ID, true)||chapterItem.CID;\\n}\\n\\nfunction novel(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    return Mian.novel(chapterItem, info, chapterItem.CID,MY_ID, true)||chapterItem.CID;\\n    //File.renameFile(chapterPath, chapterItem.CID + \\\"$A$\\\" + chapterItem.title);\\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 Mian = $.require(\\\"mainDownload\\\");\\nfunction novel(item, info, order, MY_ID) {\\n    Mian.novel(item, info, order);\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\n\\nfunction comic(item, info, order, MY_ID) {\\n    Mian.comic(item, info, order);\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\nvar $exe = {\\n    comic: comic,\\n    novel: novel\\n};\\n$.exports = function(item, info, order, MY_ID) {\\n    return $exe[info.type](item, info, order, MY_ID);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#f.通用工具\",\"path\":\"Tool.js\",\"rule\":\"const v = {\\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] = v.split(urls[i], \\\"=\\\");\\n            if (key === \\\"headers\\\") {\\n                try {\\n                    Object.assign(headers, JSON.parse(value));\\n                } catch (e) {\\n                    log(e.toString());\\n                }\\n            } else if (key.includes(\\\".\\\") || key.includes(\\\"?\\\")) {\\n                picUrl += \\\"@\\\" + key + (value ? \\\"=\\\" + value : \\\"\\\");\\n            } else if (key !== \\\"js\\\") {\\n                headers[key] = value;\\n            }\\n        }\\n        return [picUrl, headers];\\n    },\\n    range(start, end) {\\n        return Array(end - start).fill(0).map((el, i) => start + i);\\n    },\\n    picDownload(url, path, headers, deciphe) {\\n        if (typeof deciphe === \\\"string\\\" && deciphe.length > 0) {\\n            let instream;\\n            let outstream;\\n            let file;\\n            try {\\n                file = new java.io.File(path);\\n                if (file.exists()) {\\n                    return;\\n                }\\n                let dir = file.getParentFile();\\n                if (dir != null && !dir.exists()) {\\n                    dir.mkdirs();\\n                }\\n                instream = fetch(url, {\\n                    headers: headers,\\n                    inputStream: true\\n                });\\n\\n                outstream = new java.io.FileOutputStream(path);\\n                let t = $.hiker.input,\\n                    c = $.hiker.url;\\n                $.hiker.input = instream;\\n                $.hiker.url = url;\\n                let picin = (new Function(\\\"return \\\" + deciphe))();\\n                $.hiker.input = t;\\n                $.hiker.url = c;\\n                let buf = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 1024);\\n                let len;\\n                while ((len = picin.read(buf)) != -1) {\\n                    outstream.write(buf, 0, len);\\n                }\\n                closeMe(instream);\\n                closeMe(outstream);\\n            } catch (e) {\\n                closeMe(instream);\\n                closeMe(outstream);\\n                if (file instanceof java.io.File && file.exists()) {\\n                    file.delete();\\n                }\\n                log(\\\"<解密下载Error>\\\" + e.toString())\\n                throw e;\\n            } finally {\\n                closeMe(instream);\\n                closeMe(outstream);\\n            }\\n\\n        } else {\\n            requireDownload(url, path, headers);\\n        }\\n    },\\n    textShield(text) {\\n        let e = /#|:|&|\\\\||\\\\^|@|\\\\<|\\\\>|%|\\\\/|\\\\?/g;\\n        return text.replace(e, \\\"_\\\");\\n    }\\n    \\n}\\n\\n$.exports = v;\"},{\"col_type\":\"movie_3\",\"name\":\"#j.Config\",\"path\":\"Config.json\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js?rule=本地资源管理\\\");\\n\\nlet localConfig = {};\\n\\ntry {\\n    localConfig = JSON.parse(File.readFile(getPath(\\\"hiker://files/rules/files/本地资源管理/config.json\\\").slice(7)));\\n} catch (e) {\\n    deleteFile(\\\"config.json\\\");\\n}\\nconst Config = Object.assign({\\n    homePath: getPath(\\\"hiker://files/localManager\\\").slice(7),\\n    logNum: 10,\\n    threadNum: 0,\\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    def_isComicCompatible: \\\"0\\\"\\n}, localConfig);\\nconst PATHS = {\\n    novelPath: \\\"/小说/\\\",\\n    comicPath: \\\"/漫画/\\\",\\n    novelFullPath: \\\"/小说合并/\\\",\\n    externalImportPath: \\\"/外导小说/\\\",\\n    contentsCache: \\\"/目录缓存/\\\"\\n}\\n\\n\\nObject.keys(PATHS).forEach(key => Config[key] = Config.homePath + PATHS[key]);\\n$.exports = Config;\\n\"},{\"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\\\", getItem(\\\"main:type\\\", Config.def_Lord_Type));\\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            setItem(\\\"main:type\\\", \\\"comic\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_3\\\",\\n    });\\n    layout.push({\\n        title: type === \\\"novel\\\" ? \\\"◉小说\\\" : \\\"○小说\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((type) => {\\n            if (type === \\\"novel\\\") return \\\"hiker://empty\\\";\\n            putMyVar(\\\".type\\\", \\\"novel\\\");\\n            setItem(\\\"main:type\\\", \\\"novel\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_3\\\",\\n    });\\n    layout.push({\\n        title: type === \\\"txt\\\" ? \\\"◉整本小说\\\" : \\\"○整本小说\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((type) => {\\n            if (type === \\\"txt\\\") return \\\"hiker://page/NovelCollected.view#noRecordHistory##noHistory#\\\";\\n            putMyVar(\\\".type\\\", \\\"txt\\\");\\n            setItem(\\\"main:type\\\", \\\"txt\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_3\\\"\\n    });\\n    if (type === \\\"txt\\\") {\\n        txtView = $.require(\\\"hiker://page/externalimportTxt.view\\\");\\n        return txtView(layout);\\n    }\\n    let tag = File.getFilePath(Config[type + \\\"Path\\\"], \\\"dir\\\");\\n    if (tag.length === 0) {\\n        layout.push({\\n            col_type: \\\"line_blank\\\",\\n        });\\n        layout.push({\\n            title: \\\"设置\\\",\\n            url: \\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\",\\n            col_type: \\\"text_2\\\",\\n            extra: {\\n                version: MY_RULE.version\\n            }\\n        });\\n\\n        layout.push({\\n            title: \\\"““帮助””\\\",\\n            url: \\\"hiker://page/help.view#noRefresh##noRecordHistory##noHistory#?keyword=novelComic\\\",\\n            col_type: \\\"text_2\\\"\\n        });\\n        layout.push({\\n            title: '<h1 style=\\\"text-align: center;\\\">啥都没有耶</h1>',\\n            col_type: \\\"rich_text\\\"\\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: $([\\\"删除该目录\\\", \\\"跳转小程序\\\", \\\"打开书架\\\"], 1, \\\"选择操作\\\").select((it, type) => {\\n                    if (\\\"跳转小程序\\\" === input) {\\n                        return \\\"hiker://home@\\\" + it.name;\\n                    } else if(\\\"删除该目录\\\"===input){\\n                        //return then([\\\"该操作不会删除小程序，但该小程序下载的所有漫画将被删除\\\"]);\\n                        return $(\\\"该操作不会删除小程序，但该小程序下载的所有 漫画/小说 将被删除\\\").confirm((path) => {\\n                            const File = $.require(\\\"hiker://page/File.js\\\");\\n                            if (File.deleteFiles(path)) {\\n                                clearMyVar(\\\".tgnum\\\");\\n                                refreshPage();\\n                                return \\\"toast://删除成功\\\";\\n                            } else {\\n                                return \\\"toast://删除失败\\\";\\n                            }\\n                        }, it.path);\\n                    }else{\\n                        return \\\"hiker://page/Bookrack.view?rule=本地资源管理&ruleName=\\\"+it.name+\\\"&type=\\\"+type;\\n                    }\\n                }, it, type)\\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: Object.assign(item, {\\n                longClick: [{\\n                    title: \\\"删除\\\",\\n                    js: $.toString((path) => {\\n                        return $.require(\\\"longPress.js\\\").deleteFileForBook(path)\\n                    }, item.path)\\n                }],\\n                id: item.path\\n            })\\n        });\\n    }\\n    setResult(layout);\\n}\\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([\\n    [\\\"A\\\", \\\"\\\"],\\n    [\\\"B\\\", \\\"‘‘[未完成]’’\\\"]\\n]);\\n\\nfunction getTitle(title) {\\n    let titles = Tool.split(title, \\\"$\\\", 2);\\n    return comicStatus.get(titles[1]) + titles[2] || title;\\n}\\nfunction getTitle2(title){\\n    let titles = Tool.split(title, \\\"$\\\", 2);\\n    return titles[2] || title;\\n}\\nlayout.push({\\n    title: \\\"删除整本\\\",\\n    url: $(\\\"确认删除整本漫画？\\\").confirm((path) => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFiles(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 = [];\\n\\nif (mode === \\\"0\\\") {\\n    if (Config.def_isComicCompatible === \\\"0\\\") {\\n        let lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n            const File = $.require(\\\"hiker://page/File.js\\\");\\n            let filelist = File.getFilePath(input);\\n            let shorten = input.replace(getPath(\\\"hiker://files/\\\").slice(7),\\\"hiker://files/\\\");\\n            let piclist = filelist.map((item, i) => shorten + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n            return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n        });\\n        for (let item of mhlist) {\\n            let title = getTitle(item.name);\\n            array.push({\\n                title: title,\\n                url: item.path + lazy,\\n                col_type: Config.def_View_Style,\\n            });\\n        }\\n    } else {\\n        for (let item of mhlist) {\\n            let title = getTitle(item.name);\\n            array.push({\\n                title: title,\\n                url: \\\"hiker://page/comicCompatible.view#autoPage##readTheme#?path=\\\"+item.path,\\n                col_type: Config.def_View_Style,\\n                extra: {\\n                    path: item.path,\\n                    title: getTitle2(item.name)\\n                }\\n            });\\n        }\\n    }\\n\\n} else {\\n    for (let item of mhlist) {\\n        let name = getTitle2(item.name);\\n        array.push({\\n            title: name,\\n            url: $(\\\"确认删除[\\\" + name + \\\"]？\\\").confirm((path) => {\\n                const File = $.require(\\\"hiker://page/File.js\\\");\\n                if (File.deleteFiles(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 searchTest;\\n\\nif (!getSearchMode()) {\\n    let termsArr = searchTerms.split(\\\"\\\").map(t => t.replace(/\\\\*|\\\\.|\\\\?|\\\\+|\\\\$|\\\\^|\\\\[|\\\\]|\\\\(|\\\\)|\\\\{|\\\\}|\\\\||\\\\/|\\\\\\\\/g, k => \\\"\\\\\\\\\\\" + k));\\n    let reg = new RegExp(termsArr.join(\\\".*\\\"), \\\"i\\\");\\n    searchTest = text => reg.test(text);\\n} else {\\n    searchTest = text => searchContains(text, searchTerms, false);\\n}\\n\\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 (searchTest(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: \\\"hiker://page/Setting/More.view#noRefresh##noRecordHistory##noHistory#?settingType=contents\\\",\\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\\\", 0) || \\\"{}\\\");\\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), 0);\\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\\\", 0) || \\\"{}\\\");\\n\\n        Config.def_isPaginate = def_isPaginate === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\";\\n\\n        saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\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: $(\\\"#noLoading#\\\").lazyRule((def_isComicCompatible) => {\\n        let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n\\n        Config.def_isComicCompatible = def_isComicCompatible === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\";\\n\\n        saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, Config.def_isComicCompatible),\\n    desc: Config.def_isComicCompatible === \\\"0\\\" ? \\\"不开启\\\" : \\\"开启\\\",\\n    col_type: \\\"text_1\\\"\\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});\\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});\\nlayout.push({\\n    title: \\\"文件管理\\\",\\n    url: \\\"hiker://page/FileManagement.view#noRefresh##noRecordHistory##noHistory#\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlet tid = Date.now();\\nlayout.push({\\n    title: \\\"检测更新\\\",\\n    col_type: \\\"text_1\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((oldVersion, tid) => {\\n        try {\\n            let newVersion = JSON.parse(request(\\\"http://hiker.nokia.press/hikerule/dev/getbyid?id=3559\\\", {\\n                timeout: 2000\\n            })).result.ver;\\n            if (newVersion <= oldVersion) {\\n                updateItem(tid + \\\"#设置_更新\\\", {\\n                    title: \\\"已经是最新版本了\\\"\\n                });\\n                return \\\"toast://已经是最新版本了\\\";\\n            } else {\\n                updateItem(tid + \\\"#设置_更新\\\", {\\n                    title: \\\"有新版本还未更新\\\"\\n                });\\n                toast(\\\"有新版本还未更新\\\");\\n                return \\\"rule://5rW36ZiU6KeG55WM77+laG9tZV9ydWxlX3VybO+/pWh0dHA6Ly9oaWtlci5ub2tpYS5wcmVzcy9oaWtlcnVsZS9ydWxlbGlzdC5qc29uP2lkPTM1NTk=\\\";\\n            }\\n        } catch (e) {\\n            updateItem(tid + \\\"#设置_更新\\\", {\\n                title: \\\"信息获取失败\\\"\\n            });\\n            return \\\"toast://更新信息获取失败\\\";\\n        }\\n    }, MY_PARAMS.version, tid),\\n    extra: {\\n        id: tid + \\\"#设置_更新\\\"\\n    }\\n});\\nlayout.push({\\n    title: \\\"关于如何调用\\\",\\n    url: \\\"mqqapi://forward/url?src_type=web&style=default&plg_auth=1&version=1&url_prefix=aHR0cHM6Ly9xdW4ucXEuY29tL3Fxd2ViL3F1bnByby9zaGFyZT9fd3Y9MyZfd3d2PTEyOCZpbnZpdGVDb2RlPTFIRnlCSiZmcm9tPTI0NjYxMCZiaXo9a2EjL291dA==\\\",\\n    desc: \\\"详细点击加入频道(快来华山与我论[ji]剑)\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"问题反馈\\\",\\n    url: \\\"mqqapi://forward/url?src_type=web&style=default&plg_auth=1&version=1&url_prefix=aHR0cHM6Ly9xdW4ucXEuY29tL3Fxd2ViL3F1bnByby9zaGFyZT9fd3Y9MyZfd3d2PTEyOCZhcHBDaGFubmVsPXNoYXJlJmludml0ZUNvZGU9MVhOYWxBRXl2VmomY29udGVudElEPWMzbElQJmJ1c2luZXNzVHlwZT0yJmZyb209MTgxMDc0JmJpej1rYSZtYWluU291cmNlSWQ9c2hhcmUmc3ViU291cmNlSWQ9b3RoZXJzJmp1bXBzb3VyY2U9c2hvcnR1cmw=&t=1671893123597#Intent;scheme=mqqapi;package=com.tencent.mobileqq;end\\\",\\n    desc: \\\"绝对不会有bug(啊我不接受!)\\\",\\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.deleteFiles(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) {\\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    const bookInfo = Object.assign({\\n        selected: [],\\n        isReplace: true\\n    }, JSON.parse(request(\\\"file://\\\" + paths.path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\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 = bookInfo.isReplace ? entirePath + \\\".tmp\\\" : entirePath;\\n\\n    if (fileExist(\\\"file://\\\" + entirePath)) {\\n        toast(\\\"初始化文件\\\");\\n        if (!File.deleteFiles(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(/&nbsp;/g,\\\"\\\").split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it=>it.trim()).join(\\\"\\\\r　　\\\") + \\\"\\\\n\\\\n\\\");\\n    }\\n    if (bookInfo.isReplace) {\\n        let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\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                if (!bookInfo.selected.includes(replaceRule.id)) {\\n                    continue;\\n                }\\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),\\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: \\\"净化\\\",\\n    url: \\\"hiker://page/NovelCustom.view#noRecordHistory##noHistory##noRefresh#\\\",\\n    extra: MY_PARAMS,\\n    col_type: \\\"scroll_button\\\"\\n});\\nlayout.push({\\n    title: \\\"外部查看\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((path) => {\\n        const Config = $.require(\\\"hiker://page/Config.json\\\");\\n        let entirePath = path.replace(Config.novelPath, Config.novelFullPath) + \\\".txt\\\";\\n        if (fileExist(\\\"file://\\\" + entirePath)) {\\n            toast(\\\"调用第三方应用打开文件\\\");\\n            return \\\"openFile://file://\\\" + entirePath\\n        } else {\\n            return \\\"toast://本地暂无可供外部打开的txt文件，请先合并小说！\\\"\\n        }\\n    }, path),\\n    col_type: \\\"scroll_button\\\"\\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(\\\"file://\\\" + 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(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n            bookInfo.foot = inputNum;\\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(\\\"file://\\\" + 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(\\\"file://\\\" + 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                dirPath: path,\\n                title: name,\\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.deleteFiles(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,\\\" \\\");\\nconst bookInfo = Object.assign({\\n    selected: [],\\n    isReplace: true\\n}, JSON.parse(request(\\\"file://\\\" + MY_PARAMS.dirPath + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\ncontent = \\\"　　\\\" + content.split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it=>it.trim()).join(\\\"<br>　　\\\");\\n\\nif (bookInfo.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 (!bookInfo.selected.includes(replaceRule.id)) {\\n            continue;\\n        }\\n        let replace = replacePattern[0 + replaceRule.isRegex];\\n        javaString = javaString[replace](replaceRule.pattern, replaceRule.replacement);\\n    }\\n    content = String(javaString);\\n}\\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.合并TXT\",\"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\\\");\\nsetPageTitle(\\\"合并TXT\\\");\\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.deleteFiles(path)) {\\n                refreshPage();\\n                return \\\"toast://删除成功\\\";\\n            } else {\\n                return \\\"toast://删除失败\\\";\\n            }\\n            break;\\n        case \\\"海阔预览\\\":\\n            return \\\"hiker://page/txtParser.view\\\";\\n            break;\\n        case \\\"打开方式\\\":\\n            return \\\"openFile://file://\\\" + path;\\n            break;\\n    }\\n}\\nfor (let rulePaths of rulelDir) {\\n    let novels = File.getFilePath(rulePaths.path, \\\"file\\\", \\\".txt\\\");\\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            extra: {\\n                path: novel.path\\n            }\\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 = [];\\nlet id = \\\"#\\\" + new Date().getTime();\\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.externalImportPath), \\\"#管理器#导入的TXT目录[不建议清除]\\\"],\\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.deleteFiles(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        if (getMyVar(\\\":defaultPicBack\\\")) {\\n            back();\\n            clearMyVar(\\\":defaultPicBack\\\");\\n            break;\\n        }\\n\\n        function setDefaultPic(url) {\\n            let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n            Config.def_Pic = url;\\n            saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n            back();\\n            return \\\"toast://修改成功\\\";\\n        }\\n        let start = 1;\\n        if (typeof(MY_NAME) !== \\\"undefined\\\" && MY_NAME === \\\"嗅觉浏览器\\\") {\\n            start = 4;\\n        }\\n        for (let i = start; 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        layout.push({\\n            title: \\\"自定义➕\\\",\\n            col_type: \\\"text_3\\\",\\n            url: $([\\\"自定义url\\\", \\\"选择文件路径\\\"]).select(() => {\\n                if (input === \\\"自定义url\\\") {\\n                    return $(\\\"\\\", \\\"输入图片的路径或者链接\\\").input(() => {\\n                        let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n                        Config.def_Pic = input;\\n                        saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n                        back();\\n                        return \\\"toast://修改成功\\\";\\n                    });\\n                } else {\\n                    let requireUrl = \\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\";\\n                    let fileSelect = require(requireUrl);\\n                    return fileSelect.fileSelectionUri({\\n                        callback: $.toString(() => {\\n                            let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n                            Config.def_Pic = \\\"file://\\\" + PATH;\\n                            saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n                            putMyVar(\\\":defaultPicBack\\\", \\\"true\\\");\\n                            back();\\n                            return \\\"toast://修改成功\\\";\\n                        }),\\n                        requireUrl: requireUrl,\\n                        fileType: \\\".jpg|.jpeg|.gif|.png|.svg|.bmp\\\",\\n                        onClickType: \\\"confirm\\\",\\n                        memory: \\\"selectPathCache2\\\"\\n                    });\\n                }\\n            })\\n        });\\n        break;\\n    case \\\"replaceRule\\\":\\n        if (MY_PARAMS.isRefresh) {\\n            addListener(\\\"onClose\\\", $.toString(() => refreshPage()));\\n        }\\n        setPageTitle(\\\"替换规则|设置\\\");\\n        let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\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\\n        function importRule(isback) {\\n            input = typeof PATH === \\\"undefined\\\" ? input : PATH;\\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                    if (!newRule.hasOwnProperty(\\\"replacement\\\") || !newRule.hasOwnProperty(\\\"pattern\\\") || !newRule.hasOwnProperty(\\\"name\\\") || (newRule.scopeContent === undefined ? false : !newRule.scopeContent)) {\\n                        continue;\\n                    }\\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                if (isback) {\\n                    back();\\n                } else {\\n                    refreshPage();\\n                }\\n                log(\\\"\\\\n路径：\\\" + input + \\\"\\\\n总规则数：\\\" + newRuleList.length + \\\"\\\\n更新规则 \\\" + updateCount + \\\" 条\\\\t新增规则 \\\" + newCount + \\\" 条\\\");\\n                toast(\\\"导入成功\\\");\\n            } catch (e) {\\n                log(e.toString());\\n                if (isback) back();\\n                toast(\\\"导入失败\\\");\\n            }\\n        }\\n        layout.push({\\n            title: \\\"导入规则\\\",\\n            url: $([\\\"外部文件\\\", \\\"内部文件\\\"], 1, \\\"规则导入\\\").select((importRule) => {\\n                if (input === \\\"外部文件\\\") {\\n                    return \\\"fileSelect://\\\" + $.toString(importRule);\\n                } else {\\n                    let requireUrl = \\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\";\\n                    let fileSelect = require(requireUrl);\\n                    return fileSelect.fileSelectionUri({\\n                        callback: $.toString(importRule, true),\\n                        requireUrl: requireUrl,\\n                        fileType: \\\".json\\\",\\n                        onClickType: \\\"confirm\\\",\\n                        memory: \\\"selectPathCache\\\"\\n                    });\\n                }\\n            }, importRule),\\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.name,\\n                col_type: \\\"text_1\\\",\\n                url: \\\"hiker://empty\\\",\\n                extra: {\\n                    cls: 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                    let g = ruleList.splice(index, 1);\\n\\n                    saveFile(\\\"replaceRule.json\\\", JSON.stringify(ruleList));\\n                    //deleteItemByCls(id + \\\".\\\" + index);\\n                    refreshPage(false);\\n                    toast(\\\"删除成功\\\");\\n                    return \\\"hiker://empty\\\";\\n                }, id, i),\\n                extra: {\\n                    cls: id + \\\".\\\" + i\\n                },\\n                col_type: \\\"text_2\\\"\\n            });\\n            layout.push({\\n                title: \\\"编辑\\\",\\n                url: \\\"hiker://page/editReplaceRule.view#noRecordHistory##noHistory##noRefresh#?index=\\\" + i,\\n                col_type: \\\"text_2\\\",\\n                extra: {\\n                    cls: id + \\\".\\\" + i\\n                }\\n            });\\n            layout.push({\\n                col_type: \\\"line_blank\\\",\\n                extra: {\\n                    cls: id + \\\".\\\" + i\\n                }\\n            });\\n        }\\n        break;\\n    case \\\"contents\\\":\\n        let f = require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\n        setPageTitle(\\\"目录设置|设置\\\");\\n        layout.push({\\n            title: \\\"选择文件夹\\\",\\n            url: JSON.stringify(f.fileSelectionUri({\\n                callback: $.toString((id) => {\\n                    let target = findItem(id).extra;\\n                    updateItem(id, {\\n                        extra: Object.assign(target, {\\n                            defaultValue: PATH\\n                        })\\n                    });\\n                    return true;\\n                }, id),\\n                initialPath: Config.homePath,\\n                requireUrl: \\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\",\\n                pattern: 1\\n            })),\\n            col_type: \\\"input\\\",\\n            desc: \\\"支持hiker://files路径(该操作不会初始化目录)\\\",\\n            extra: {\\n                defaultValue: Config.homePath,\\n                onChange: $.toString((id) => {\\n                    putMyVar(id, input);\\n                }, id),\\n                id: id\\n            }\\n        });\\n        layout.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n        layout.push({\\n            title: \\\"确认\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n                let input = getMyVar(id, findItem(id).extra.defaultValue || \\\"\\\");\\n                const Config = $.require(\\\"hiker://page/Config.json\\\");\\n                if (input.startsWith(\\\"hiker://files/\\\")) input = getPath(input).slice(7);\\n                if (input.endsWith(\\\"/\\\")) input=input.replace(/\\\\/$/,\\\"\\\");\\n                if (Config.homePath == input) return \\\"toast://已经是当前目录\\\";\\n                Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n                Config.homePath = input;\\n                saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n                back();\\n                return \\\"toast://已保存\\\";\\n            }, id),\\n            col_type: \\\"text_center_1\\\",\\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        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);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.小说个性化净化\",\"path\":\"NovelCustom.view\",\"rule\":\"js:\\nsetPageTitle(\\\"替换规则|\\\" + MY_PARAMS.name);\\nlet ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\nlet id = \\\"#\\\" + new Date().getTime();\\n\\nconst bookInfo = Object.assign({\\n    foot: 0,\\n    isReplace: true,\\n    selected: []\\n}, JSON.parse(request(\\\"file://\\\" + MY_PARAMS.path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\n\\nlet layout = [];\\nlayout.push({\\n    title: [\\\"☐净化\\\", \\\"☑净化\\\"][0 + bookInfo.isReplace],\\n    url: $(\\\"#noLoading#\\\").lazyRule(($id, path) => {\\n\\n        var bookInfo = JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n        let isReplace = bookInfo.isReplace===undefined?true:bookInfo.isReplace;\\n        bookInfo.isReplace = !isReplace;\\n        writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n        updateItem($id, {\\n            title: isReplace ? \\\"☐净化\\\" : \\\"☑净化\\\",\\n        });\\n        return \\\"hiker://empty\\\";\\n    }, id + \\\"#-1\\\", MY_PARAMS.path),\\n    extra: {\\n        id: id + \\\"#-1\\\"\\n    },\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    title: \\\"编辑规则\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRecordHistory##noHistory##noRefresh#?settingType=replaceRule\\\",\\n    col_type: \\\"text_2\\\",\\n    extra:{\\n        isRefresh: true\\n    }\\n});\\nfor (let i = 0, len = ruleList.length; i < len; i++) {\\n    let replaceRule = ruleList[i];\\n    let isTrue = bookInfo.selected.includes(replaceRule.id);\\n    layout.push({\\n        title: (isTrue ? \\\"●\\\" : \\\"○\\\") + replaceRule.name,\\n        col_type: \\\"text_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        y: 0,\\n        extra: {\\n            isTrue: isTrue,\\n            id: id + i,\\n            lineVisible: false\\n        }\\n    });\\n    layout.push({\\n        title: \\\"开启\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(($id, replaceRule, path) => {\\n            if (findItem($id).extra.isTrue) {\\n                return \\\"toast://已开启\\\";\\n            }\\n            const bookInfo = Object.assign({\\n                selected: []\\n            }, JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\n            bookInfo.selected.push(replaceRule.id);\\n            updateItem($id, {\\n                title: \\\"●\\\" + replaceRule.name,\\n                extra: {\\n                    isTrue: true,\\n                    id: $id,\\n                    lineVisible: false\\n                }\\n            });\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            return \\\"hiker://empty\\\";\\n        }, id + i, replaceRule, MY_PARAMS.path),\\n        col_type: \\\"text_2\\\"\\n    });\\n    layout.push({\\n        title: \\\"关闭\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(($id, replaceRule, path) => {\\n            if (!findItem($id).extra.isTrue) {\\n                return \\\"toast://已关闭\\\";\\n            }\\n            const bookInfo = Object.assign({\\n                selected: []\\n            }, JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\n            bookInfo.selected.splice(bookInfo.selected.indexOf(replaceRule.id), 1);\\n            updateItem($id, {\\n                title: \\\"○\\\" + replaceRule.name,\\n                extra: {\\n                    isTrue: false,\\n                    id: $id,\\n                    lineVisible: false\\n                }\\n            });\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            return \\\"hiker://empty\\\";\\n        }, id + i, replaceRule, MY_PARAMS.path),\\n        col_type: \\\"text_2\\\"\\n    });\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n}\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.外导小说\",\"path\":\"externalimportTxt.view\",\"rule\":\"js:\\nfunction txtView(layout) {\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n    const Config = $.require(\\\"hiker://page/Config.json\\\");\\n    let files = File.getFilePath(Config.externalImportPath);\\n    files = files.filter(v => /(\\\\.txt|\\\\.epub)$/.test(v.name));\\n\\n    setPageTitle(\\\"小说书架\\\");\\n    //let layout = [];\\n    layout.push({\\n        url: 'input?\\\"hiker://page/txtSearch.view#noRefresh#?searchTerms=\\\"+encodeURIComponent(input):\\\"toast://请输入小说名\\\"',\\n        desc: \\\"搜索\\\",\\n        title: \\\"🔍\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            defaultValue: getMyVar(\\\"searchKeyByTxt\\\", \\\"\\\"),\\n            onChange: \\\"putMyVar('searchKeyByTxt',input)\\\"\\n        }\\n    });\\n    layout.push({\\n        title: \\\"导入小说\\\",\\n        col_type: \\\"text_3\\\",\\n        url: $([\\\"系统选择器\\\", \\\"海阔选择器\\\"], 1, \\\"选择器类型\\\").select(() => {\\n            if (input === \\\"系统选择器\\\") {\\n                return \\\"fileSelect://\\\" + $.toString(() => {\\n                    if (!/(\\\\.txt|.epub)$/i.test(input)) {\\n                        toast(\\\"选择了错误的文件类型\\\");\\n                        return;\\n                    }\\n                    const Config = $.require(\\\"hiker://page/Config.json\\\");\\n                    let fileMatch = input.match(/\\\\/([^\\\\/]*?)(\\\\.txt|\\\\.epub)$/i);\\n                    let novelName = fileMatch[1].replace(\\\"_fileSelect_\\\", \\\"\\\");\\n                    let topath = Config.externalImportPath + novelName + fileMatch[2];\\n                    let topathCache = Config.contentsCache + novelName + fileMatch[2];\\n                    let path = input.replace(\\\"file://\\\", \\\"\\\");\\n                    if (fileExist(\\\"file://\\\" + topath)) {\\n                        confirm({\\n                            title: \\\"导入提示\\\",\\n                            content: \\\"已存在[\\\" + novelName + \\\"]是否覆盖?\\\",\\n                            confirm: $.toString((path, topath, topathCache) => {\\n                                const File = $.require(\\\"hiker://page/File.js\\\");\\n                                File.copyFile(path, topath, true);\\n                                if (fileExist(\\\"file://\\\" + topathCache)) {\\n                                    File.deleteFiles(topathCache);\\n                                }\\n                                refreshPage(false);\\n                                return \\\"toast://导入成功\\\";\\n                            }, path, topath, topathCache)\\n                        });\\n                        return;\\n                    } else {\\n                        const File = $.require(\\\"hiker://page/File.js\\\");\\n                        File.copyFile(path, topath);\\n                        if (fileExist(\\\"file://\\\" + topathCache)) {\\n                            File.deleteFiles(topathCache);\\n                        }\\n                        refreshPage(false);\\n                        toast(\\\"导入成功\\\");\\n                        return;\\n                    }\\n                });\\n            } else {\\n                let requireUrl = \\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\";\\n                let fileSelect = require(requireUrl);\\n                return fileSelect.fileSelectionUri({\\n                    callback: $.toString(() => {\\n                        const Config = $.require(\\\"hiker://page/Config.json\\\");\\n                        let fileMatch = PATH.match(/\\\\/([^\\\\/]*?)(\\\\.txt|\\\\.epub)$/i);\\n                        let novelName = fileMatch[1];\\n                        let topath = Config.externalImportPath + novelName + fileMatch[2];\\n                        let topathCache = Config.contentsCache + novelName + fileMatch[2];\\n                        let path = PATH;\\n                        if (fileExist(\\\"file://\\\" + topath)) {\\n                            return $(\\\"已存在[\\\" + novelName + \\\"]是否覆盖?\\\").confirm((path, topath, topathCache) => {\\n                                const File = $.require(\\\"hiker://page/File.js\\\");\\n                                File.copyFile(path, topath, true);\\n                                if (fileExist(\\\"file://\\\" + topathCache)) {\\n                                    File.deleteFiles(topathCache);\\n                                }\\n                                back();\\n                                return \\\"toast://导入成功\\\";\\n                            }, path, topath, topathCache);\\n                        } else {\\n                            const File = $.require(\\\"hiker://page/File.js\\\");\\n                            File.copyFile(path, topath);\\n                            if (fileExist(\\\"file://\\\" + topathCache)) {\\n                                File.deleteFiles(topathCache);\\n                            }\\n                            back();\\n                            return \\\"toast://导入成功\\\";\\n                        }\\n                    }),\\n                    requireUrl: requireUrl,\\n                    fileType: \\\".txt|.epub\\\",\\n                    onClickType: \\\"confirm\\\",\\n                    memory: \\\"selectPathCache1\\\"\\n                });\\n            }\\n        }),\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n    let options = [\\\"阅读\\\", \\\"分享\\\", \\\"删除\\\", \\\"打开方式\\\"];\\n\\n    let pattern = getMyVar(\\\":txtPattern\\\", options[0]);\\n    let id = Date.now() + \\\":模式\\\";\\n    layout.push({\\n        title: pattern,\\n        col_type: \\\"text_3\\\",\\n        url: $(options, 1, \\\"操作模式\\\").select((id) => {\\n            putMyVar(\\\":txtPattern\\\", input);\\n            updateItem(id, {\\n                title: input\\n            });\\n        }, id),\\n        extra: {\\n            id: id\\n        }\\n    });\\n    layout.push({\\n        title: \\\"文件管理\\\",\\n        col_type: \\\"text_3\\\",\\n        url: \\\"hiker://page/FileManagement.view#noRefresh##noRecordHistory##noHistory#?type=externalImportPath\\\"\\n    });\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n\\n    function operation(path, name, type) {\\n        let pattern = getMyVar(\\\":txtPattern\\\", \\\"阅读\\\");\\n        switch (pattern) {\\n            case \\\"分享\\\":\\n                return \\\"share://\\\" + path;\\n                break;\\n            case \\\"删除\\\":\\n                return $(\\\"确认删除[\\\" + name + \\\"]\\\").confirm((path) => {\\n                    const File = $.require(\\\"hiker://page/File.js\\\");\\n                    if (File.deleteFiles(path)) {\\n                        if (fileExist(\\\"file://\\\" + path + \\\".json\\\")) {\\n                            File.deleteFiles(path + \\\".json\\\");\\n                        }\\n                        //refreshPage();\\n                        deleteItem(path)\\n                        return \\\"toast://删除成功\\\";\\n                    } else {\\n                        return \\\"toast://删除失败\\\";\\n                    }\\n                }, path);\\n                break;\\n            case \\\"阅读\\\":\\n                return (type===\\\".txt\\\"?\\\"hiker://page/txtParser.view\\\":\\\"hiker://page/epubParser.view#autoCache#\\\")+\\\"?rule=\\\" + MY_RULE.title;\\n                break;\\n            case \\\"打开方式\\\":\\n                return \\\"openFile://file://\\\" + path;\\n                break;\\n        }\\n    }\\n\\n    for (let novel of files) {\\n        let type = novel.name.substring(novel.name.lastIndexOf(\\\".\\\"));\\n        layout.push({\\n            title: novel.name,\\n            url: $(\\\"#noLoading#\\\").lazyRule(operation, novel.path, novel.name, type),\\n            desc: \\\"大小：\\\" + File.getFileSize(novel.path) + \\\"\\\\n修改时间：\\\" + $.dateFormat(novel.lastModified, \\\"yyyy-MM-dd HH:mm:ss\\\"),\\n            col_type: \\\"text_1\\\",\\n            extra: {\\n                path: novel.path,\\n                isCache: true,\\n                title: novel.name,\\n                id: novel.path,\\n                longClick: [{\\n                    title: \\\"分享\\\",\\n                    js: JSON.stringify(\\\"share://\\\" + novel.path)\\n                }, {\\n                    title: \\\"阅读\\\",\\n                    js: JSON.stringify((type===\\\".txt\\\"?\\\"hiker://page/txtParser.view\\\":\\\"hiker://page/epubParser.view#autoCache#\\\")+\\\"?rule=\\\" + MY_RULE.title)\\n                }, {\\n                    title: \\\"打开方式\\\",\\n                    js: JSON.stringify(\\\"openFile://file://\\\" + novel.path)\\n                }, {\\n                    title: \\\"删除\\\",\\n                    js: $.toString((path) => {\\n                        return $.require(\\\"longPress.js\\\").deleteFileForTxt(path)\\n                    }, novel.path)\\n                }]\\n            }\\n        });\\n    }\\n    if (files.length === 0) {\\n        layout.push({\\n            title: \\\"设置\\\",\\n            url: \\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\",\\n            col_type: \\\"text_2\\\",\\n            extra: {\\n                version: MY_RULE.version\\n            }\\n        });\\n\\n        layout.push({\\n            title: \\\"““帮助””\\\",\\n            url: \\\"hiker://page/help.view#noRefresh##noRecordHistory##noHistory#?keyword=txt\\\",\\n            col_type: \\\"text_2\\\"\\n        });\\n        layout.push({\\n            title: '<h1 style=\\\"text-align: center;\\\">啥都没有耶</h1>',\\n            col_type: \\\"rich_text\\\"\\n        });\\n    }\\n    setResult(layout);\\n}\\nif ($.importParam === undefined) {\\n    $.exports = txtView;\\n} else if ($.importParam === null) {\\n    setResult(txtView([]));\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#v.TXT解析器\",\"path\":\"txtParser.view\",\"rule\":\"js:\\n(function() {\\n    const Config = $.require(\\\"Config.json\\\");\\n    let regs = $.require(\\\"hiker://page/regularChapter.f\\\");\\n    let path = decodeURIComponent(getParam(\\\"path\\\") || \\\"\\\") || MY_PARAMS.path;\\n    let charst = decodeURIComponent(getParam(\\\"charst\\\") || \\\"\\\") || MY_PARAMS.charst || \\\"UTF-8\\\";\\n    let isCache = decodeURIComponent(getParam(\\\"isCache\\\") || \\\"\\\") || MY_PARAMS.isCache;\\n    if (!path.startsWith(\\\"file://\\\")) {\\n        path = \\\"file://\\\" + path;\\n    }\\n    if(MY_PARAMS.title){\\n        setPageTitle(MY_PARAMS.title);\\n    }else{\\n        setPageTitle($.require(\\\"hiker://page/File.js\\\").getName(path));\\n    }\\n    let layout = [];\\n    let chapterNames = [];\\n    let intervals = [];\\n    let hasPreface = false;\\n    let cachePath = path.replace(Config.externalImportPath, Config.contentsCache);\\n    if (isCache&&fileExist(cachePath)) {\\n        try {\\n\\n            let c = JSON.parse(request(cachePath));\\n            chapterNames = c.chapterNames;\\n            intervals = c.intervals;\\n            hasPreface = c.hasPreface;\\n            layout.push({\\n                title: \\\"重新解析目录\\\",\\n                col_type: \\\"text_center_1\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((path) => {\\n                    deleteFile(path);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }, path+\\\".json\\\"),\\n                extra: {\\n                    lineVisible:false\\n                }\\n            });\\n            layout.push({\\n                col_type:\\\"line_blank\\\"\\n            });\\n        } catch (e) {\\n            log(e.toString());\\n            setResult([{\\n                title: \\\"““””<strong>目录解析失败(重新解析)</strong>\\\".big(),\\n                col_type: \\\"text_center_1\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((path) => {\\n                    deleteFile(path);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }, path+\\\".json\\\"),\\n                extra: {\\n                    lineVisible: false\\n                }\\n            }]);\\n            return;\\n        }\\n\\n    } else {\\n        showLoading(\\\"正在解析目录\\\");\\n        let txt = request(path, {\\n            headers: {\\n                //\\\"content-type\\\": \\\"text/plain; charst=\\\" + charst\\n            }\\n        });\\n        let pattern = regs.getTocRule(txt);\\n        if (!pattern) {\\n            hideLoading();\\n            setResult([{\\n                title: \\\"““””<strong>目录解析失败</strong>\\\".big(),\\n                col_type: \\\"text_center_1\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n                    back(false);\\n                    return \\\"hiker://empty\\\";\\n                }),\\n                extra: {\\n                    lineVisible: false\\n                }\\n            }]);\\n            return;\\n        }\\n        let matcher = pattern.matcher(txt);\\n        let pointer = 0;\\n        while (matcher.find()) {\\n            let start = matcher.start();\\n            let end = matcher.end();\\n            let t = matcher.group();\\n            if (pointer === 0 && start > 30) {\\n                hasPreface = true;\\n            }\\n            chapterNames.push(t);\\n            intervals.push([pointer, start]);\\n            pointer = end;\\n        }\\n        intervals.push([pointer, txt.length]);\\n        if (isCache) {\\n            writeFile(cachePath, JSON.stringify({\\n                chapterNames: chapterNames,\\n                intervals: intervals,\\n                hasPreface: hasPreface\\n            }));\\n        }\\n        hideLoading();\\n    }\\n\\n\\n    if (hasPreface) {\\n        let interval = intervals[0];\\n        layout.push({\\n            title: \\\"序言\\\",\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/TXTViewer.view#autoPage##readTheme#\\\",\\n            extra: {\\n                chapterName: \\\"序言\\\",\\n                start: interval[0],\\n                end: interval[1],\\n                path: path,\\n                charst: charst\\n            }\\n        });\\n    }\\n    for (let i = 0; i < chapterNames.length; i++) {\\n        let name = chapterNames[i];\\n        let interval = intervals[i + 1];\\n        layout.push({\\n            title: name,\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/TXTViewer.view#autoPage##readTheme#\\\",\\n            extra: {\\n                start: interval[0],\\n                end: interval[1],\\n                chapterName: name,\\n                path: path,\\n                charst: charst\\n            }\\n        });\\n    }\\n    setResult(layout);\\n})()\"},{\"col_type\":\"movie_3\",\"name\":\"#v.TXT查看器\",\"path\":\"TXTViewer.view\",\"rule\":\"js:\\nlet path = MY_PARAMS.path;\\nlet charst = MY_PARAMS.charst;\\nlet txt = request(path, {\\n    headers: {\\n       //\\\"content-type\\\": \\\"text/plain; charst=\\\" + charst\\n    }\\n});\\n\\nlet targetTexts = txt.substring(MY_PARAMS.start, MY_PARAMS.end);\\n\\nlet content = targetTexts.split(/(\\\\n|\\\\r)+/).filter(it => it.length > 1).join(\\\"<br>\\\");\\nlet layout = [];\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + MY_PARAMS.chapterName + \\\"</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\":\"movie_3\",\"name\":\"#j.章节正则\",\"path\":\"regularChapter.f\",\"rule\":\"js:\\nlet rules = [{\\n        \\\"id\\\": -1,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"目录(去空白)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和]))).{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 假装第一章前面有空白但我不要\\\",\\n        \\\"serialNumber\\\": 0\\n    },\\n    {\\n        \\\"id\\\": -2,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"目录\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|篇(?!张))).{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 标准的粤语就是这样\\\",\\n        \\\"serialNumber\\\": 1\\n    },\\n    {\\n        \\\"id\\\": -3,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"目录(匹配简介)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])(?:(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|回(?![合来事去])|场(?![和合比电是])|篇(?!张))).{0,30}$\\\",\\n        \\\"example\\\": \\\"简介 老夫诸葛村夫\\\",\\n        \\\"serialNumber\\\": 2\\n    },\\n    {\\n        \\\"id\\\": -4,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"目录(古典、轻小说备用)\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|回(?![合来事去])|场(?![和合比电是])|话|篇(?!张))).{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 比上面只多了回和话\\\",\\n        \\\"serialNumber\\\": 3\\n    },\\n    {\\n        \\\"id\\\": -5,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"数字(纯数字标题)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])\\\\\\\\d+\\\\\\\\.?[ 　\\\\\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"12\\\",\\n        \\\"serialNumber\\\": 4\\n    },\\n    {\\n        \\\"id\\\": -6,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"大写数字(纯数字标题)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])[〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,12}[ 　\\\\\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"一百七十\\\",\\n        \\\"serialNumber\\\": 4\\n    },\\n    {\\n        \\\"id\\\": -7,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"数字 分隔符 标题名称\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}\\\\\\\\d{1,5}[:：,.， 、_—\\\\\\\\-].{1,30}$\\\",\\n        \\\"example\\\": \\\"1、这个就是标题\\\",\\n        \\\"serialNumber\\\": 5\\n    },\\n    {\\n        \\\"id\\\": -8,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"大写数字 分隔符 标题名称\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|[〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8})[ 、_—\\\\\\\\-].{1,30}$\\\",\\n        \\\"example\\\": \\\"一、只有前面的数字有差别\\\",\\n        \\\"serialNumber\\\": 6\\n    },\\n    {\\n        \\\"id\\\": -9,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"正文 标题/序号\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}正文[ 　]{1,4}.{0,20}$\\\",\\n        \\\"example\\\": \\\"正文 我奶常山赵子龙\\\",\\n        \\\"serialNumber\\\": 7\\n    },\\n    {\\n        \\\"id\\\": -10,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"Chapter/Section/Part/Episode 序号 标题\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:[Cc]hapter|[Ss]ection|[Pp]art|ＰＡＲＴ|[Nn][oO]\\\\\\\\.|[Ee]pisode|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)\\\\\\\\s{0,4}\\\\\\\\d{1,4}.{0,30}$\\\",\\n        \\\"example\\\": \\\"Chapter 1 MyGrandmaIsNB\\\",\\n        \\\"serialNumber\\\": 8\\n    },\\n    {\\n        \\\"id\\\": -11,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"Chapter(去简介)\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:[Cc]hapter|[Ss]ection|[Pp]art|ＰＡＲＴ|[Nn][Oo]\\\\\\\\.|[Ee]pisode)\\\\\\\\s{0,4}\\\\\\\\d{1,4}.{0,30}$\\\",\\n        \\\"example\\\": \\\"Chapter 1 MyGrandmaIsNB\\\",\\n        \\\"serialNumber\\\": 9\\n    },\\n    {\\n        \\\"id\\\": -12,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"特殊符号 序号 标题\\\",\\n        \\\"rule\\\": \\\"(?<=[\\\\\\\\s　])[【〔〖「『〈［\\\\\\\\[](?:第|[Cc]hapter)[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,10}[章节].{0,20}$\\\",\\n        \\\"example\\\": \\\"【第一章 后面的符号可以没有\\\",\\n        \\\"serialNumber\\\": 10\\n    },\\n    {\\n        \\\"id\\\": -13,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"特殊符号 标题(成对)\\\",\\n        \\\"rule\\\": \\\"(?<=[\\\\\\\\s　]{0,4})(?:[\\\\\\\\[〈「『〖〔《（【\\\\\\\\(].{1,30}[\\\\\\\\)】）》〕〗』」〉\\\\\\\\]]?|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)[ 　]{0,4}$\\\",\\n        \\\"example\\\": \\\"『加个直角引号更专业』\\\",\\n        \\\"serialNumber\\\": 11\\n    },\\n    {\\n        \\\"id\\\": -14,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"特殊符号 标题(单个)\\\",\\n        \\\"rule\\\": \\\"(?<=[\\\\\\\\s　]{0,4})(?:[☆★✦✧].{1,30}|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)[ 　]{0,4}$\\\",\\n        \\\"example\\\": \\\"☆、晋江作者最喜欢的格式\\\",\\n        \\\"serialNumber\\\": 12\\n    },\\n    {\\n        \\\"id\\\": -15,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"章/卷 序号 标题\\\",\\n        \\\"rule\\\": \\\"^[ \\\\\\\\t　]{0,4}(?:(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|[卷章][\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8})[ 　]{0,4}.{0,30}$\\\",\\n        \\\"example\\\": \\\"卷五 开源盛世\\\",\\n        \\\"serialNumber\\\": 13\\n    },\\n    {\\n        \\\"id\\\": -16,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"顶格标题\\\",\\n        \\\"rule\\\": \\\"^\\\\\\\\S.{1,20}$\\\",\\n        \\\"example\\\": \\\"不超过20个字顶格写的都是标题\\\",\\n        \\\"serialNumber\\\": 14\\n    },\\n    {\\n        \\\"id\\\": -17,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"双标题(前向)\\\",\\n        \\\"rule\\\": \\\"(?m)(?<=[ \\\\\\\\t　]{0,4})第[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$(?=[\\\\\\\\s　]{0,8}第[\\\\\\\\d零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章)\\\",\\n        \\\"example\\\": \\\"第一章 真正的标题并假装换行第一章 这个不要\\\",\\n        \\\"serialNumber\\\": 15\\n    },\\n    {\\n        \\\"id\\\": -18,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"双标题(后向)\\\",\\n        \\\"rule\\\": \\\"(?m)(?<=[ \\\\\\\\t　]{0,4}第[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$[\\\\\\\\s　]{0,8})第[\\\\\\\\d零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 这个标题不要并假装换行第一章真正的标题\\\",\\n        \\\"serialNumber\\\": 16\\n    },\\n    {\\n        \\\"id\\\": -19,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"书名 括号 序号\\\",\\n        \\\"rule\\\": \\\"^.{1,20}[(（][\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}[)）][ 　\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"标题后面数字有括号(12)\\\",\\n        \\\"serialNumber\\\": 17\\n    },\\n    {\\n        \\\"id\\\": -20,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"书名 序号\\\",\\n        \\\"rule\\\": \\\"^.{1,20}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}[ 　\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"标题后面数字没有括号124\\\",\\n        \\\"serialNumber\\\": 18\\n    }\\n];\\nlet Matcher = java.util.regex.Matcher;\\nlet Pattern = java.util.regex.Pattern;\\n\\nfunction getTocRule(content) {\\n    let maxCs = 1;\\n    let tocPattern = null;\\n    for (let tocRule of rules) {\\n        if (!tocRule.enable) continue;\\n        let pattern = Pattern.compile(tocRule.rule, Pattern.MULTILINE);\\n        let matcher = pattern.matcher(content);\\n        let cs = 0;\\n        while (matcher.find()) {\\n            cs++;\\n        }\\n        if (cs >= maxCs) {\\n            maxCs = cs;\\n            tocPattern = pattern;\\n        }\\n    }\\n    return tocPattern;\\n}\\n$.exports.getTocRule = getTocRule;\"},{\"col_type\":\"movie_3\",\"name\":\"#V.帮助\",\"path\":\"help.view\",\"rule\":\"js:\\nlet helpText = {\\n    \\\"txt\\\": `\\n        <h1 id=\\\"txt是什么\\\">TXT是什么?</h1>\\n        <p><a href=\\\"https://baike.baidu.com/item/txt/1217330\\\">我已经帮你百度了</a>；简单来说就是一种储存小说的文件(扩展名:txt)。</p>\\n        <h1 id=\\\"如何用该小程序阅读txt小说\\\">如何用该小程序阅读txt小说?</h1>\\n        <p>在主页面 ◉TXT 界面下，点击导入TXT，选择目标小说文件(txt文件，<em>该操作不会删除txt文件，而是copy一份到小程序的路径下</em>)，导入后再在 ◉TXT 界面下选择想要阅读的小说即可。</p>\\n\\n    `,\\n    \\\"novelComic\\\": `\\n        <h1 id=\\\"这个小程序有什么用？\\\">这个小程序有什么用？</h1>\\n        <ul>\\n        <li><u>代码上为其他小程序(漫画类/小说类)提供下载接口。</u></li>\\n        <li><u>本体充当阅读器，可以浏览用该小程序提供的下载接口(上面)，下载的漫画/小说。</u></li>\\n        <li><u>提供TXT格式小说文件解析功能。</u>\\n        <h1 id=\\\"为什么列表里什么都没用\\\">为什么列表里什么都没用?</h1>\\n        <u>初次使用，没有很正常吧。🤔</u>\\n        <h1 id=\\\"该如何添加漫画或小说\\\">该如何添加漫画(或小说)?</h1>\\n        <u> 在一个有下载功能的小程序(漫画类/小说类)中下载一本漫画/小说，返回该规则即可浏览。</u></li>\\n        </ul>\\n    `\\n};\\nsetPageTitle(\\\"帮助\\\");\\nlet keyword = getParam(\\\"keyword\\\");\\nlet text;\\nif (keyword === undefined || !(text = helpText[keyword])) {\\n    setResult([{\\n        title: '<h1 style=\\\"text-align: center;\\\">资料不见咯</h1>',\\n        col_type: \\\"rich_text\\\"\\n    }]);\\n} else {\\n    setResult([{\\n        title: text,\\n        col_type: \\\"rich_text\\\"\\n    }]);\\n}\"},{\"col_type\":\"text_1\",\"name\":\"#v.外导搜索\",\"path\":\"txtSearch.view\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nlet searchTerms = decodeURIComponent(getParam(\\\"searchTerms\\\"));\\nsetPageTitle(\\\"「\\\" + searchTerms + \\\"」的搜索结果\\\");\\nlet data = File.getFilePath(Config.externalImportPath, undefined);\\ndata = data.filter(v => /(\\\\.txt|\\\\.epub)$/.test(v.name));\\n\\nlet termsArr = searchTerms.split(\\\"\\\").map(t => t.replace(/\\\\*|\\\\.|\\\\?|\\\\+|\\\\$|\\\\^|\\\\[|\\\\]|\\\\(|\\\\)|\\\\{|\\\\}|\\\\||\\\\/|\\\\\\\\/g, k => \\\"\\\\\\\\\\\" + k));\\nlet reg = new RegExp(termsArr.join(\\\".*\\\"), \\\"i\\\");\\nlet searchResult = [];\\nfor (let txt of data) {\\n    if (reg.test(txt.name)) {\\n        let type = txt.name.substring(txt.name.lastIndexOf(\\\".\\\"));\\n        searchResult.push({\\n            title: txt.name,\\n            url: (type===\\\".txt\\\"?\\\"hiker://page/txtParser.view\\\":\\\"hiker://page/epubParser.view#autoCache#\\\")+\\\"?rule=\\\" + MY_RULE.title,\\n            desc: txt.path,\\n            extra: {\\n                path: txt.path,\\n                isCache: true,\\n                title: txt.name\\n            }\\n        });\\n    }\\n}\\nif (searchResult.length === 0) {\\n    searchResult.push({\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        title: '<h2 style=\\\"text-align: center;\\\">🔎没有找到相关书籍</h2>',\\n        col_type: \\\"rich_text\\\"\\n    });\\n}\\nsetResult(searchResult);\"},{\"col_type\":\"movie_3\",\"name\":\"#f.长按\",\"path\":\"longPress.js\",\"rule\":\"js:\\n$.exports = {\\n    deleteFileForBook(path) {\\n        //return $(\\\"所有的 漫画/小说 章节将被删除\\\\m确认删除？\\\").confirm((path) => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFiles(path)) {\\n            deleteItem(path)\\n            return \\\"toast://删除成功\\\";\\n        } else {\\n            return \\\"toast://删除失败\\\";\\n        }\\n        //}, path);\\n    },\\n    deleteFileForTxt(path) {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFiles(path)) {\\n            if (fileExist(\\\"file://\\\" + path + \\\".json\\\")) {\\n                File.deleteFiles(path + \\\".json\\\");\\n            }\\n            deleteItem(path);\\n            return \\\"toast://删除成功\\\";\\n        } else {\\n            return \\\"toast://删除失败\\\";\\n        }\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.下载主程序\",\"path\":\"mainDownload\",\"rule\":\"const File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n\\n$.exports.novel = function novel(item, info, order, MY_ID, interrupt) {\\n    let mainPath = Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + Tool.textShield(info.bookName) + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$A$\\\" + Tool.textShield(item.title) + \\\".txt\\\";\\n    let content = \\\"\\\";\\n    if (interrupt && getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n        return -1;\\n    }\\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            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1], info.decode);\\n\\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}\\n\\n$.exports.comic = function comic(item, info, order, MY_ID, interrupt) {\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + Tool.textShield(info.bookName) + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$B$\\\" + Tool.textShield(item.title) + \\\"/\\\";\\n    let picList = [];\\n    try {\\n        let getPicList = new Function(\\\"input\\\", \\\"url\\\", \\\"return\\\" + info.parseCode);\\n        picList = getPicList(item.url, 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    picList = picList.filter(p => p);\\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            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1], info.decode);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n\\n    let errorNum = 0;\\n    for (var i = 0; i < L; i++) {\\n        try {\\n            let pic = Tool.hikerPic(picList[i]);\\n            Tool.picDownload(pic[0], chapterPath + (i + 1) + \\\".jpg\\\", pic[1], info.decode);\\n            if (interrupt && getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n                return -1;\\n            }\\n            errorNum = 0;\\n        } catch (e) {\\n            if (errorNum < 10) {\\n                i--;\\n                errorNum++;\\n                continue;\\n            } else {\\n                throw e;\\n            }\\n        }\\n    }\\n\\n    File.renameFile(chapterPath, order + \\\"$A$\\\" + Tool.textShield(item.title));\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"#v.漫画兼容\",\"path\":\"comicCompatible.view\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nsetPageTitle($.log(MY_PARAMS.title));\\nlet filelist = File.getFilePath(MY_PARAMS.path);\\nlet piclist = filelist.map((item, i) => ({\\n    col_type: \\\"pic_1_full\\\",\\n    url: \\\"hiker://empty\\\",\\n    pic_url: MY_PARAMS.path + \\\"/\\\" + (i + 1) + \\\".jpg\\\"\\n}));\\n\\nsetResult(piclist);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.书架\",\"path\":\"Bookrack.view\",\"rule\":\"js:\\nconst File = $.require(\\\"File.js\\\");\\nconst rank = $.require(\\\"fileRank.js\\\");\\nconst Tool = $.require(\\\"Tool.js\\\");\\nconst Config = $.require(\\\"Config.json\\\");\\n\\n(function() {\\n    let type = MY_PARAMS.type || getParam(\\\"type\\\", \\\"\\\") || \\\"comic\\\";\\n    let ruleName = Tool.textShield(MY_PARAMS.ruleName || decodeURIComponent(getParam(\\\"ruleName\\\")));\\n    if (!ruleName) {\\n        toast(\\\"请传入规则名\\\");\\n        back(false);\\n    }\\n    if (![\\\"comic\\\", \\\"novel\\\"].includes(type)) {\\n        toast(\\\"请传入正确的type:comic novel\\\");\\n        back(false);\\n    }\\n    setPageTitle(ruleName + \\\"|本地书架\\\");\\n    let layout = [];\\n    let path = Config[type + \\\"Path\\\"] + ruleName;\\n    let col_type = getItem(\\\"bookrack:col_type\\\", \\\"movie_3_marquee\\\");\\n    let rankMethod = getItem(\\\"bookrack:rankMethod\\\", \\\"系统\\\");\\n    let rankIsReverse = getItem(\\\"bookrack:rankIsReverse\\\", \\\"\\\");\\n\\n    let colTypes = [\\\"movie_1\\\", \\\"movie_2\\\", \\\"movie_3_marquee\\\", \\\"movie_1_vertical_pic\\\", \\\"pic_2\\\", \\\"pic_3\\\", \\\"pic_3_square\\\", \\\"pic_2_card\\\"];\\n    \\n    let rankMethods = [\\\"系统\\\", \\\"大小\\\", \\\"名称\\\", \\\"时间\\\"];\\n    layout.push({\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        desc: \\\"搜你想要的#\\\" + type + \\\"#......\\\",\\n        title: \\\"🔍\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            rules: $.toString((ruleName, type) => {\\n                let arr1 = [{\\n                        \\\"title\\\": ruleName,\\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                return JSON.stringify(arr1);\\n            }, ruleName, type),\\n            /*defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"*/\\n        }\\n    });\\n\\n    layout.push({\\n        title: \\\"🧩\\\",\\n        col_type: \\\"flex_button\\\",\\n        url: $(colTypes.map(v=>v===col_type?\\\"““\\\"+v+\\\"””\\\":v)).select((name) => {\\n            if(/““.*?””/.test(input)) return;\\n            setItem(\\\"bookrack:col_type\\\", input);\\n            refreshPage();\\n        })\\n    });\\n    for (let name of rankMethods) {\\n        let a = rankMethod === name;\\n        let titlea = a ? \\\"‘‘\\\" + name + \\\"’’\\\" : name;\\n        let titleb = \\\"\\\";\\n        if (a) {\\n            titleb = !rankIsReverse ? \\\"↓\\\" : \\\"↑\\\";\\n        } else {\\n            titleb = \\\"↕\\\";\\n        }\\n        layout.push({\\n            title: titlea + titleb,\\n            col_type: \\\"flex_button\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule((name) => {\\n                let rankMethod = getItem(\\\"bookrack:rankMethod\\\", \\\"系统\\\");\\n                let rankIsReverse = getItem(\\\"bookrack:rankIsReverse\\\", \\\"\\\");\\n\\n                if (rankMethod === name) {\\n                    if (rankIsReverse) {\\n                        rankIsReverse = \\\"\\\";\\n                    } else {\\n                        rankIsReverse = \\\"1\\\";\\n                    }\\n\\n                    setItem(\\\"bookrack:rankIsReverse\\\", rankIsReverse);\\n                } else {\\n                    setItem(\\\"bookrack:rankIsReverse\\\", \\\"\\\");\\n                    setItem(\\\"bookrack:rankMethod\\\", name);\\n\\n                }\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\";\\n            }, name)\\n        });\\n    }\\n    let rankMethodMap = {\\n        \\\"系统\\\": \\\"\\\",\\n        \\\"大小\\\": \\\"size\\\",\\n        \\\"名称\\\": \\\"name\\\",\\n        \\\"时间\\\": \\\"time\\\"\\n    };\\n    let bookList = [];\\n    let list = rank(File.getFiles(path, \\\"dir\\\"), rankMethodMap[rankMethod]);\\n    if (list.length === 0) {\\n        bookList.push({\\n            title: \\\"““””\\\" + \\\"啥都没有耶\\\".big(),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n\\n    }\\n    let pageUrl = type === \\\"novel\\\" ? \\\"hiker://page/NovelBrowser.view\\\" : \\\"hiker://page/ComicBrowser.view\\\";\\n    for (let item of list) {\\n        let pic = fileExist(\\\"file://\\\" + item.getPath() + \\\"/\\\" + item.getName() + \\\".jpg\\\") ? item.getPath() + \\\"/\\\" + item.getName() + \\\".jpg\\\" : Config.def_Pic;\\n        bookList.push({\\n            title: item.getName(),\\n            pic_url: pic,\\n            url: pageUrl + \\\"?rule=\\\" + MY_RULE.title,\\n            col_type:col_type,\\n            extra: {\\n                longClick: [{\\n                    title: \\\"删除\\\",\\n                    js: $.toString((path) => {\\n                        return $.require(\\\"longPress.js\\\").deleteFileForBook(path);\\n                    }, item.getPath())\\n                }],\\n                id: item.getPath(),\\n                path: item.getPath(),\\n                name: item.getName()\\n            }\\n        });\\n    }\\n    if (rankIsReverse) {\\n        bookList.reverse();\\n    }\\n\\n    setResult(layout.concat(bookList));\\n})();\"},{\"col_type\":\"movie_3\",\"name\":\"#f.文件排序\",\"path\":\"fileRank.js\",\"rule\":\"js:\\nconst File = $.require(\\\"File.js\\\");\\nlet chnNumChar = {\\n    零: 0,\\n    一: 1,\\n    二: 2,\\n    三: 3,\\n    四: 4,\\n    五: 5,\\n    六: 6,\\n    七: 7,\\n    八: 8,\\n    九: 9\\n};\\n\\nlet chnNameValue = {\\n    十: {\\n        value: 10,\\n        secUnit: false\\n    },\\n    百: {\\n        value: 100,\\n        secUnit: false\\n    },\\n    千: {\\n        value: 1000,\\n        secUnit: false\\n    },\\n    万: {\\n        value: 10000,\\n        secUnit: true\\n    },\\n    亿: {\\n        value: 100000000,\\n        secUnit: true\\n    }\\n}\\n\\nfunction ChineseToNumber(chnStr) {\\n    let rtn = 0;\\n    let section = 0;\\n    let number = 0;\\n    let secUnit = false;\\n    let str = chnStr.split('');\\n\\n    for (let i = 0; i < str.length; i++) {\\n        let num = chnNumChar[str[i]];\\n        if (typeof num !== 'undefined') {\\n            number = num;\\n            if (i === str.length - 1) {\\n                section += number;\\n            }\\n        } else {\\n            let unit = chnNameValue[str[i]].value;\\n            secUnit = chnNameValue[str[i]].secUnit;\\n            if (secUnit) {\\n                section = (section + number) * unit;\\n                rtn += section;\\n                section = 0;\\n            } else {\\n                section += (number * unit);\\n            }\\n            number = 0;\\n        }\\n    }\\n    return rtn + section;\\n}\\n\\nfunction nameCompare(a, b) {\\n    if (a == null || b == null)\\n        return a == null ? b == null ? 0 : -1 : 1;\\n\\n    a = a.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return v.ChineseToNumber(p1);\\n    })\\n    b = b.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return v.ChineseToNumber(p1);\\n    })\\n\\n    let NUMBERS = java.util.regex.Pattern.compile(\\\"(?<=\\\\\\\\D)(?=\\\\\\\\d)|(?<=\\\\\\\\d)(?=\\\\\\\\D)\\\");\\n    let split1 = NUMBERS.split(new java.lang.String(a));\\n    let split2 = NUMBERS.split(new java.lang.String(b));\\n\\n    for (let i = 0; i < Math.min(split1.length, split2.length); i++) {\\n        let c1 = split1[i].charCodeAt(0);\\n        let c2 = split2[i].charCodeAt(0);\\n        let cmp = 0;\\n        let zeroCharCode = '0'.charCodeAt(0);\\n        let nineCharCode = '9'.charCodeAt(0);\\n\\n        if (c1 >= zeroCharCode && c1 <= nineCharCode && c2 >= zeroCharCode && c2 <= nineCharCode) {\\n            cmp = new java.math.BigInteger(split1[i]).compareTo(new java.math.BigInteger(split2[i]));\\n        }\\n\\n        if (cmp === 0) {\\n            let regex = /[a-zA-Z0-9]/\\n            let s1 = String(split1[i])\\n            let s2 = String(split2[i])\\n            if (regex.test(s1) || regex.test(s2)) {\\n                cmp = new java.lang.String(split1[i]).compareTo(new java.lang.String(split2[i]));\\n                // cmp = s1.localeCompare(s2, 'en')\\n            } else {\\n                cmp = s1.localeCompare(s2, 'zh')\\n            }\\n        }\\n\\n        if (cmp !== 0) {\\n            return cmp;\\n        }\\n    }\\n    let lengthCmp = split1.length - split2.length;\\n    // if (lengthCmp !== 0) lengthCmp = lengthCmp > 0 ? -1 : 1;\\n    return lengthCmp;\\n}\\n\\nfunction rank(list, m) {\\n    switch (m) {\\n        case \\\"type\\\":\\n            return list;\\n        case \\\"name\\\":\\n            return list.sort((a, b) => nameCompare(String(a.getName()), String(b.getName())));\\n        case \\\"size\\\":\\n            return list.sort((a, b) => File.getTotalSizeOfFilesInDir(a) - File.getTotalSizeOfFilesInDir(b));\\n        case \\\"time\\\":\\n            return list.sort((a, b) => a.lastModified() - b.lastModified());\\n        default:\\n            return list;\\n    }\\n\\n}\\n$.exports=rank;\"},{\"col_type\":\"movie_3\",\"name\":\"#v.epub解析器\",\"path\":\"epubParser.view\",\"rule\":\"js:\\nvar layout = [];\\nsetPageTitle(\\\"书籍信息\\\");\\nlet path = decodeURIComponent(getParam(\\\"path\\\") || \\\"\\\") || MY_PARAMS.path;\\nlet meta = getEpubMetadata(path);\\n//log(meta)\\n\\nlayout.push({\\n    title: meta.firstTitle,\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nlayout.push({\\n    title: \\\"👤作者：\\\" + meta.authors[0].lastname,\\n    col_type: \\\"rich_text\\\",\\n});\\nlet description = (meta.descriptions[0] || \\\"\\\").replace(/<p.*?>|<\\\\/p>/g, \\\"\\\");\\nlet tdescription = description;\\nif (description) {\\n    \\n    if (description.length > 50) {\\n        description = description.substring(0, 50) +\\\"......\\\" +\\\"更多>\\\".link($().b64(\\\"'\\\").rule(() => {\\n            setPageTitle(\\\"简介\\\");\\n            setResult([{\\n                title: \\\"简介：<br>　　\\\" + MY_PARAMS.text,\\n                col_type: \\\"rich_text\\\",\\n\\n            }]);\\n        }));\\n    }\\n    layout.push({\\n        title: \\\"📝简介：<br>　　\\\"+description,\\n        col_type: \\\"rich_text\\\",\\n        extra: {\\n            text: tdescription\\n        }\\n    });\\n}\\n//setPageTitle(meta.firstTitle);\\nlayout.push({\\n    col_type: \\\"line_blank\\\",\\n    url: \\\"hiker://empty\\\"\\n});\\nlet chapters = getEpubChapters(path);\\nfor (let it of chapters) {\\n    layout.push({\\n        title: it.title,\\n        url: \\\"hiker://page/epubViewer.view#readTheme##autoPage#\\\",\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            href: it.url,\\n            path: path,\\n            title: it.title\\n        }\\n    });\\n}\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.epub查看器\",\"path\":\"epubViewer.view\",\"rule\":\"js:\\nlet path = MY_PARAMS.path;\\nlet url = MY_PARAMS.href;\\nlet c = getEpubContent(path, url);\\n//let a= c.replace(/\\\\s?<div.*?>|<\\\\/div>\\\\s?/g, \\\"\\\").replace(/\\\\s?<p.*?>(.*)<\\\\/p>\\\\s?/g, \\\"\\\\u3000\\\\u3000$1<br>\\\");\\n//let b=c.replace(/\\\\s?<div.*?>|<\\\\/div>\\\\s?/g, \\\"\\\").replace(/\\\\s?<p.*?>(.*?)<\\\\/p>\\\\s?/g, \\\"\\\\u3000\\\\u3000$1<br>\\\");\\n//log(a==b)\\n//log(getEpubContent0(path, url))\\n\\nlet layout = [];\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + MY_PARAMS.title + \\\"</strong>\\\").big(),\\n});\\n\\nlayout.push({\\n    title: c,\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: 18,\\n        click: true\\n    }\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v文件管理\",\"path\":\"FileManagement.view\",\"rule\":\"js:\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nlet url = \\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\";\\nlet f = require(url);\\nlet type = getParam(\\\"type\\\", \\\"homePath\\\");\\naddListener(\\\"onClose\\\", () => {\\n    refreshPage();\\n});\\nlet hikerPath = \\\"file://\\\" + Config.homePath;\\nif(!fileExist(hikerPath)){\\n    writeFile(hikerPath+\\\"/创建目录.txt\\\",\\\"\\\");\\n    deleteFile(hikerPath+\\\"/创建目录.txt\\\");\\n}\\nf.fileSelection({\\n    callback: $.toString(() => {\\n        //根据文件扩展名，用不同小程序打开\\n        if (\\\".jpg\\\" === TYPE) {\\n            return PATH;\\n        } else if (\\\".txt\\\" === TYPE) {\\n            return \\\"hiker://page/txtParser.view?isCache=true&rule=\\\" + MY_RULE.title + \\\"&path=\\\" + PATH;\\n        } else if (\\\".epub\\\" === TYPE) {\\n            return \\\"hiker://page/epubParser.view#autoCache#?rule=\\\" + MY_RULE.title + \\\"&path=\\\" + PATH;\\n        } else {\\n            return $(\\\"无法打开，是否使用其他应用打开？\\\").confirm(path => \\\"openFile://file://\\\" + path, PATH);\\n        }\\n    }),\\n    initialPath: Config[type],\\n    rootDirPath: Config.homePath,\\n    //onClickType: \\\"confirm\\\",\\n    //memory: \\\"FileManagement:memory\\\",\\n    requireUrl: url,\\n    fileType: \\\"\\\\.txt|\\\\.epub|.jpg\\\",\\n    //cHomeTips: \\\"是否使用海阔小程序打开[${name}]?\\\",\\n    //cSearchTips: \\\"是否使用海阔小程序打开[${path}]?\\\"\\n});\"}]","icon":"https://lanmeiguojiang.com/tubiao/q/58.png","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
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!