API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：选择器|[综]用绳命推销的男人 作者：醉饮长歌

xiaomianao666
Oct 10th, 2022
1,229
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 395.44 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥选择器|[综]用绳命推销的男人 作者：醉饮长歌@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"#f.File工具\",\"path\":\"File.js\",\"rule\":\"const File = java.io.File;\\nconst {\\n    Files,\\n    Paths,\\n    StandardCopyOption,\\n    StandardOpenOption\\n} = java.nio.file;\\nconst javaString = java.lang.String;\\nlet javaScope = new JavaImporter(java.io, java.lang, java.lang.reflect, java.util.Vector);\\n\\nfunction 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    }\\n    if (expand) {\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\n    }\\n    return pathList;\\n}\\n\\nfunction renameFile(fromPath, name) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(fromFile.getParent() + \\\"/\\\" + name);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!deleteFlies(toPath)) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction moveFiles(fromPath, toPath) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(toPath);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!deleteFlies(toPath)) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction fileWrite(path, content) {\\n    writeFile(\\\"file://\\\" + path, content)\\n}\\n\\nfunction fileWriteAppend(path, content) {\\n    let file = new File(path);\\n    let paths = file.toPath();\\n    if (file.exists()) {\\n        Files.write(paths, new javaString(content).getBytes(), StandardOpenOption.APPEND);\\n    } else {\\n        writeFile(\\\"file://\\\" + path, content);\\n    }\\n}\\n\\nfunction getTotalSizeOfFilesInDir(file) {\\n    if (file.isFile()) {\\n        return file.length();\\n    }\\n    let children = file.listFiles();\\n    let total = 0;\\n    if (children != null) {\\n        for (let child of children) {\\n            total += getTotalSizeOfFilesInDir(child);\\n        }\\n    }\\n    return total;\\n}\\n\\nfunction getFileSize(filePath) {\\n    //Byte\\n    let size = getTotalSizeOfFilesInDir(new File(filePath));\\n    if (size < 0) {\\n        return null;\\n    }\\n    let unitForm = [\\\"Byte\\\", \\\"KB\\\", \\\"MB\\\", \\\"GB\\\", \\\"TB\\\"];\\n    for (let i = 0, len = unitForm.length; i < len; i++) {\\n        if (size > 1024) {\\n            size /= 1024;\\n            continue;\\n        } else {\\n            return 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}\"},{\"col_type\":\"text_2\",\"name\":\"#v.下载列表-普通下载\",\"path\":\"download.view\",\"rule\":\"js:\\nconst viewConfig = Object.assign({\\n    chapterList: [],\\n    info: {},\\n    defaultView: \\\"0\\\"\\n}, MY_PARAMS);\\nviewConfig.info = Object.assign({\\n    ruleName: \\\"\\\",\\n    bookName: \\\"\\\",\\n    bookTopPic: \\\"\\\",\\n    parseCode: \\\"\\\",\\n    type: \\\"comic\\\",\\n}, viewConfig.info);\\nlet {\\n    chapterList,\\n    info,\\n    defaultView\\n} = viewConfig;\\nsetPageTitle(\\\"选择器|\\\" + info.bookName)\\n\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nconst def_DoVi_Style = Config.def_DoVi_Style;\\nconst MY_ID = info.ruleName + \\\"//\\\" + info.bookName;\\n\\n\\nlet isStart = getMyVar(MY_ID + \\\":isStart\\\");\\nlet viewMode = getMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\nlet isReverse = getMyVar(MY_ID + \\\":isReverse\\\", \\\"0\\\");\\nlet tagFilter = getMyVar(MY_ID + \\\":tagFilter\\\", Config.def_DoVi_Type);\\n\\naddListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n    clearMyVar(MY_ID + \\\":loadingTeam\\\");\\n    clearMyVar(MY_ID + \\\":viewMode\\\");\\n    clearMyVar(MY_ID + \\\":completed\\\");\\n    clearMyVar(MY_ID + \\\":batchTeam\\\");\\n    clearMyVar(MY_ID + \\\":tagFilter\\\");\\n    clearMyVar(MY_ID + \\\":pageNum\\\");\\n}, MY_ID));\\n\\nlet layout = [];\\n\\nif (isStart === \\\"1\\\") {\\n    putMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\n    viewMode = \\\"1\\\";\\n}\\n\\nlet backupChapterList = chapterList;\\nif (typeof chapterList === \\\"string\\\") {\\n    chapterList = JSON.parse(request(\\\"file://\\\" + chapterList) || \\\"[]\\\");\\n}\\nlet chapterAll = chapterList;\\nchapterList = chapterList.map((item, CID) => {\\n    item.CID = CID;\\n    return item;\\n});\\nlet pageNum = Number(getMyVar(MY_ID + \\\":pageNum\\\", \\\"1\\\"));\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\nchapterList = chapterChunk[pageNum] || [];\\n\\nfunction setType() {\\n    let set = (tag, put) => {\\n        putMyVar(put, tag);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    };\\n    layout.push({\\n        title: 0 == pageNum ? \\\"““””\\\" + (\\\"全部(\\\" + chapterAll.length + \\\")\\\").fontcolor(\\\"#23AD6F\\\") : \\\"全部(\\\" + chapterAll.length + \\\")\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, 0, MY_ID + \\\":pageNum\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    for (let i = 1; i < chapterChunk.length; i++) {\\n        let tagText = (i - 1) * Config.viewPageSize + \\\"-\\\" + ((i - 1) * Config.viewPageSize + chapterChunk[i].length);\\n        layout.push({\\n            title: i == pageNum ? \\\"““””\\\" + tagText.fontcolor(\\\"#23AD6F\\\") : tagText,\\n            url: $(\\\"#noLoading#\\\").lazyRule(set, i, MY_ID + \\\":pageNum\\\"),\\n            col_type: \\\"scroll_button\\\"\\n        });\\n    }\\n    layout.push({\\n        col_type: \\\"blank_block\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"0\\\" ? \\\"““””\\\" + \\\"全部\\\".fontcolor(\\\"#23AD6F\\\") : \\\"全部\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"0\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"1\\\" ? \\\"““””\\\" + \\\"未下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"未下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"1\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"2\\\" ? \\\"““””\\\" + \\\"已下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"已下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"2\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n}\\nlet chapterTeam = [];\\nlet record = [];\\nif (info.type === \\\"comic\\\") {\\n    let lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        let filelist = File.getFilePath(input);\\n        let piclist = filelist.map((item, i) => \\\"file://\\\" + input + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n        return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n    });\\n\\n    function comFun(i, item) {\\n        let rootPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title;\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: rootPath + lazy,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"dir\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2]);\\n        }\\n    });\\n} else {\\n    function comFun(i, item) {\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n                path: Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title + \\\".txt\\\",\\n                title: item.title\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"file\\\", \\\".txt\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\".\\\")));\\n        }\\n    });\\n}\\n\\nfunction clickDownload(item, info, MY_ID, i) {\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = loadingTeam.indexOf(i);\\n    if (ElementIndex > -1) return \\\"toast://正在下载\\\";\\n\\n    loadingTeam.push(i);\\n    putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    updateItem({\\n        title: \\\"‘‘\\\" + item.title + \\\"’’\\\",\\n        extra: {\\n            id: MY_ID + \\\"#\\\" + i\\n        }\\n    });\\n    let result = \\\"toast://下载失败\\\";\\n    try {\\n        toast(\\\"开始下载:\\\" + item.title);\\n        let download = $.require(\\\"hiker://page/Download.exe.js\\\");\\n        result = download(item, info, MY_ID, i);\\n        updateItem({\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"toast://已下载\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n    } catch (e) {\\n        updateItem({\\n            title: item.title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        log(e.toString());\\n    } finally {\\n        loadingTeam.splice(ElementIndex, 1);\\n        putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    }\\n    return result;\\n}\\n\\nfunction singleView() {\\n    layout.push({\\n        title: \\\"反转列表\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((isReverse, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, isReverse, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    layout.push({\\n        title: \\\"批量下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            if (loadingTeam.length > 0) return \\\"toast://还有任务没有完成\\\";\\n            if (getAppVersion() < 2594) return \\\"toast://未开放\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"1\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n\\n        }, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: loadingTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n}\\n\\nfunction clickChoose(title, MY_ID, i) {\\n    let isStart = getMyVar(MY_ID + \\\":isStart\\\");\\n    if (isStart === \\\"1\\\") return \\\"toast://正在下载...\\\";\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = batchTeam.indexOf(i);\\n    if (ElementIndex > -1) {\\n        updateItem({\\n            title: title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.splice(ElementIndex, 1);\\n    } else {\\n        updateItem({\\n            title: \\\"‘‘\\\" + title + \\\"’’\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.push(i);\\n    }\\n    putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n    return \\\"hiker://empty\\\";\\n}\\n\\nfunction batchView() {\\n    layout.push({\\n        title: \\\"单选下载\\\",\\n        pic_url: \\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在批量下载\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"0\\\");\\n            clearMyVar(MY_ID + \\\":batchTeam\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\n    let end = start + chapterList.length;\\n    layout.push({\\n        title: \\\"选择全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = Tool.range(start, end);\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\":completed\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"取消全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = new Set(Tool.range(start, end));\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"确认选中\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\", \\\"-1\\\") !== \\\"-1\\\") {\\n                return \\\"toast://正在下载...\\\";\\n            }\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            return batchTeam.length === 0 ? \\\"toast://你还什么都没有选\\\" : \\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\";\\n        }, MY_ID),\\n        extra: {\\n            newWindow: true,\\n            windowId: MY_ID + \\\"//批量下载\\\",\\n            MY_ID: MY_ID,\\n            chapterList: backupChapterList,\\n            info: info\\n        },\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let completed = [];\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            completed.push(item.CID);\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: batchTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n    putMyVar(MY_ID + \\\":completed\\\", JSON.stringify(completed));\\n}\\nswitch (viewMode) {\\n    case \\\"0\\\":\\n        singleView();\\n        break;\\n    case \\\"1\\\":\\n        batchView();\\n        break;\\n}\\nif (isReverse === \\\"1\\\") {\\n    chapterTeam.reverse();\\n}\\nlayout.push.apply(layout, chapterTeam);\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.批量下载器\",\"path\":\"Batch.view\",\"rule\":\"js:\\nlet {\\n    chapterList,\\n    info,\\n    MY_ID\\n} = MY_PARAMS;\\nsetPageTitle(\\\"下载器|\\\"+info.bookName);\\naddListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n    clearMyVar(MY_ID + \\\":isStart\\\");\\n    clearMyVar(MY_ID + \\\":status\\\");\\n    clearMyVar(MY_ID + \\\":batchTeam\\\");\\n    refreshPage();\\n}, MY_ID));\\n\\nlet isStart = getMyVar(MY_ID + \\\":isStart\\\", \\\"0\\\");\\nlet status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\nlet layout = [];\\n\\nlet batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\nif(typeof chapterList === \\\"string\\\"){\\n    chapterList = JSON.parse(request(\\\"file://\\\"+chapterList)||\\\"[]\\\");\\n}\\nlet chapterTeam = batchTeam.map(v => {\\n    let chapterItem = chapterList[v];\\n    chapterItem.CID = v;\\n    return chapterItem;\\n});\\nif (isStart === \\\"0\\\") {\\n    layout.push({\\n        title: \\\"开始下载[\\\" + chapterTeam.length + \\\"]\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((chapterTeam, info, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isStart\\\", \\\"1\\\");\\n            refreshPage(false);\\n            let download = $.require(\\\"hiker://page/BatchStatistics.js\\\");\\n            return download(chapterTeam, info, MY_ID) || \\\"toast://下载错误\\\";\\n        }, chapterTeam, info, MY_ID),\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"||开始下载\\\"\\n        }\\n    });\\n    layout.push({\\n        title: \\\"任务列表：\\\",\\n        col_type: \\\"rich_text\\\",\\n    });\\n    for (let item of chapterTeam) {\\n        layout.push({\\n            title: item.title,\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_2\\\"\\n        });\\n    }\\n\\n} else {\\n    layout.push({\\n        title: \\\"下载进度:0/\\\"+chapterTeam.length,\\n        desc: \\\"““””▇▇▇▇▇▇▇▇▇▇\\\".fontcolor(\\\"#e5e1e4\\\")+\\\" 0%\\\",\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"||下载进度\\\",\\n            lineVisible: false\\n        }\\n    });\\n    layout.push({\\n        title: \\\"后台下载\\\",\\n        url: \\\"func://background\\\",\\n        col_type: \\\"text_2\\\"\\n    });\\n\\n    layout.push({\\n        title: [\\\"[取消下载]\\\", \\\"[正在停止...]\\\", \\\"[返回]\\\", \\\"[处理失败]\\\", \\\"[重新开始]\\\"][status],\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n            if (status === \\\"0\\\") {\\n                putMyVar(MY_ID + \\\":status\\\", \\\"1\\\");\\n                updateItem({\\n                    title: \\\"[正在停止...]\\\",\\n                    extra: {\\n                        id: MY_ID + \\\"||下载控制\\\"\\n                    }\\n                });\\n                return \\\"toast://正在取消下载任务\\\";\\n            } else if (status === \\\"1\\\") {\\n                return \\\"toast://正在暂停...\\\";\\n            } else if (status === \\\"2\\\") {\\n                back();\\n                return \\\"toast://已退出下载器\\\";\\n            } else if ([\\\"3\\\", \\\"4\\\"].includes(status)) {\\n                clearMyVar(MY_ID + \\\":isStart\\\");\\n                clearMyVar(MY_ID + \\\":status\\\");\\n                clearMyVar(MY_ID + \\\":log\\\");\\n                refreshPage();\\n                return \\\"toast://重新点击下载\\\"\\n            }\\n        }, MY_ID),\\n        col_type: \\\"text_2\\\",\\n        extra: {\\n            id: MY_ID + \\\"||下载控制\\\"\\n        }\\n    });\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    layout.push({\\n        title: \\\"<strong>下载日志</strong>\\\".big(),\\n        col_type: \\\"rich_text\\\",\\n        \\n    });\\n    layout.push({\\n        col_type: \\\"line\\\",\\n        extra: {\\n            id: MY_ID + \\\"||日志\\\"\\n        }\\n    });\\n    layout.push({\\n        title:\\\"““””$>\\\"+\\\"开始下载......\\\".fontcolor(\\\"#00ff00\\\"),\\n        url:\\\"hiker://empty\\\",\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"#log#0\\\",\\n            lineVisible:false\\n        }\\n    });\\n}\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.批量下载统计\",\"path\":\"BatchStatistics.js\",\"rule\":\"const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nfunction task(taskParam) {\\n    let result = $.require(\\\"hiker://page/Batch.exe.js\\\")(taskParam);\\n    return result;\\n}\\n\\n$.exports = function(chapterTeam, info, MY_ID) {\\n    if (chapterTeam.length === 0) {\\n        return \\\"toast://空的下载队列\\\";\\n    }\\n    var count = 0;\\n    var taskCount = chapterTeam.length;\\n    var successCID = [];\\n    var failName = [];\\n    var logCount = 1;\\n    var taskTeam = chapterTeam.map(chapterItem => ({\\n        func: task,\\n        id: chapterItem.title,\\n        param: {\\n            chapterItem: chapterItem,\\n            info: info,\\n            MY_ID: MY_ID\\n        }\\n    }));\\n    let logNum = Config.logNum;\\n\\n    function putLog(text) {\\n        log(text);\\n        if (logCount >= logNum) {\\n            deleteItem(MY_ID + \\\"#log#\\\" + (logCount - 10));\\n        }\\n        addItemAfter(MY_ID + \\\"||日志\\\", {\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"$>\\\" + text,\\n            col_type: \\\"text_1\\\",\\n            extra: {\\n                lineVisible: false,\\n                id: MY_ID + \\\"#log#\\\" + logCount\\n            }\\n        });\\n        logCount++;\\n    }\\n\\n    function listener(perch, id, error, CID) {\\n        count++;\\n        let isSuccess = false;\\n        if (error !== null) {\\n            failName.push(id);\\n            putLog(\\\"[listener]下载失败：\\\" + id + \\\"<ERROR@ \\\" + error + \\\">\\\");\\n        } else if (CID >= 0) {\\n            successCID.push(CID);\\n            let ratio = (count / taskCount).toFixed(4);\\n            let stripCount = Math.ceil(ratio * 10);\\n            isSuccess = true;\\n            updateItem({\\n                title: \\\"下载进度：\\\" + successCID.length + \\\"/\\\" + taskCount,\\n                desc: \\\"““””\\\" + \\\"▇\\\".repeat(stripCount).fontcolor(\\\"#ffac2d\\\") + \\\"▇\\\".repeat(10 - stripCount).fontcolor(\\\"#e5e1e4\\\") + \\\" \\\" + (ratio * 100) + \\\"%\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载进度\\\"\\n                }\\n            });\\n            putLog(\\\"[listener]已完成下载：\\\" + id);\\n        } else if (CID === -1) {\\n            failName.push(id);\\n            putLog(\\\"[listener]已停止：\\\" + id);\\n        }\\n        if (taskCount !== count) return;\\n        if (successCID.length === taskCount) {\\n            updateItem({\\n                desc: \\\"““””\\\" + \\\"▇\\\".repeat(10).fontcolor(\\\"#00ff00\\\") + \\\" 100%\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载进度\\\"\\n                }\\n            });\\n        }\\n        let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n        let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n        let failTeam = batchTeam.filter(v => !successCID.includes(v));\\n        putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(failTeam));\\n        if (failTeam.length > 0 && status !== \\\"1\\\") {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"3\\\");\\n            putLog(\\\"下载失败:[\\\" + failName.join(\\\"]，[\\\") + \\\"]。\\\");\\n            updateItem({\\n                title: \\\"[处理失败]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        } else if (failTeam.length > 0 && status === \\\"1\\\") {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"4\\\");\\n            putLog(\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\");\\n            updateItem({\\n                title: \\\"[重新开始]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        } else {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"2\\\");\\n            putLog(\\\"下载任务[\\\" + info.bookName + \\\"]已全部成功完成\\\");\\n            updateItem({\\n                title: \\\"[返回]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        }\\n        toast(\\\"下载任务[\\\" + info.bookName + \\\"]已完成\\\");\\n    }\\n    let taskTeamChunk = [];\\n    if (Config.threadNum > 0) {\\n        taskTeamChunk = Tool.chunk(taskTeam, Config.threadNum);\\n    } else {\\n        taskTeamChunk = [taskTeam];\\n    }\\n    for (let taskList of taskTeamChunk) {\\n        be(taskList, {\\n            func: listener\\n        });\\n        let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n        if (status === \\\"1\\\") {\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n            let failTeam = batchTeam.filter(v => !successCID.includes(v));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(failTeam));\\n            putMyVar(MY_ID + \\\":status\\\", \\\"4\\\");\\n            putLog(\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\");\\n            updateItem({\\n                title: \\\"[重新开始]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n            return \\\"hiker://empty\\\";\\n        }\\n\\n    }\\n\\n    return \\\"hiker://empty\\\";\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.批量主程序\",\"path\":\"Batch.exe.js\",\"rule\":\"const File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n\\nfunction comic(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n        return -1;\\n    }\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + chapterItem.CID + \\\"$B$\\\" + chapterItem.title + \\\"/\\\";\\n    let picList;\\n    try {\\n        let getPicList = new Function(\\\"input\\\", \\\"url\\\", \\\"return \\\" + info.parseCode);\\n        picList = getPicList(chapterItem.url, chapterItem.url);\\n        if (typeof picList === \\\"string\\\") {\\n            picList = picList.replace(\\\"pics://\\\", \\\"\\\").split(\\\"&&\\\");\\n        }\\n    } catch (e) {\\n        e.message = \\\"<漫画图片解析错误：\\\" + e.message + \\\">\\\";\\n        throw e;\\n    }\\n    const L = picList.length;\\n    if(L===0){\\n        throw new Error(\\\"<漫画图片解析错误：图片链接返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误：\\\" + e.message + \\\">\\\");\\n        }\\n    }\\n    var schedule = new Map([\\n        [L, () => log(chapterItem.title + \\\"已下载100%\\\")],\\n        [~~(0.90 * L), () => log(chapterItem.title + \\\"已下载90%+\\\")],\\n        [~~(0.75 * L), () => log(chapterItem.title + \\\"已下载75%+\\\")],\\n        [~~(0.50 * L), () => log(chapterItem.title + \\\"已下载50%+\\\")],\\n        [~~(0.25 * L), () => log(chapterItem.title + \\\"已下载25%+\\\")]\\n    ]);\\n    for (var i = 0; i < L; i++) {\\n        let pic = Tool.hikerPic(picList[i]);\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\".jpg\\\", pic[1]);\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\n        if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n            return -1;\\n        }\\n    }\\n    File.renameFile(chapterPath, chapterItem.CID + \\\"$A$\\\" + chapterItem.title);\\n    return chapterItem.CID;\\n}\\n\\nfunction novel(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n        return -1;\\n    }\\n    let mainPath = Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + chapterItem.CID + \\\"$A$\\\" + chapterItem.title + \\\".txt\\\";\\n    let content = \\\"\\\";\\n    try {\\n        let getContent = new Function(\\\"input\\\", \\\"url\\\", \\\"return \\\" + info.parseCode);\\n        content = getContent(chapterItem.url, chapterItem.url);\\n    } catch (e) {\\n        e.message = \\\"<小说正文解析错误：\\\" + e.message + \\\">\\\";\\n        throw e;\\n    }\\n    if (!content) {\\n        throw new Error(\\\"<小说正文解析错误：正文返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误：\\\" + e.message + \\\">\\\");\\n        }\\n    }\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\/script>/gmi, \\\"\\\").trimRight());\\n    //File.renameFile(chapterPath, chapterItem.CID + \\\"$A$\\\" + chapterItem.title);\\n    return chapterItem.CID;\\n}\\nvar $exe = {\\n    comic: comic,\\n    novel: novel\\n};\\n$.exports = function(taskParam) {\\n    return $exe[taskParam.info.type](taskParam);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.普通主程序\",\"path\":\"Download.exe.js\",\"rule\":\"const File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n\\nfunction novel(item, info, MY_ID, order) {\\n    let mainPath = Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$A$\\\" + item.title + \\\".txt\\\";\\n    let content = \\\"\\\";\\n    try {\\n        let getContent = new Function(\\\"input\\\", \\\"url\\\", \\\"return \\\" + info.parseCode);\\n        content = getContent(item.url, item.url) || \\\"\\\";\\n    } catch (e) {\\n        e.message = \\\"<小说正文解析错误> \\\" + e.message;\\n        throw e;\\n    }\\n    if (!content) {\\n        toast(\\\"小说为空\\\");\\n        throw new Error(\\\"<小说正文解析错误：正文返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\/script>/gmi, \\\"\\\").trimRight());\\n    //File.renameFile(chapterPath, order + \\\"$A$\\\" + item.title + \\\".txt\\\");\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\n\\nfunction comic(item, info, MY_ID, order) {\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$B$\\\" + item.title + \\\"/\\\";\\n    let picList = [];\\n    try {\\n        let getPicList = new Function(\\\"input\\\", \\\"return\\\" + info.parseCode);\\n        picList = getPicList(item.url);\\n        if (typeof picList === \\\"string\\\") {\\n            picList = picList.replace(\\\"pics://\\\", \\\"\\\").split(\\\"&&\\\");\\n        }\\n    } catch (e) {\\n        e.message = \\\"<漫画图片解析错误> \\\" + e.message;\\n        throw e;\\n    }\\n\\n    const L = picList.length;\\n    if(L===0){\\n        toast(\\\"图片链接为空\\\");\\n        throw new Error(\\\"<漫画图片解析错误：图片链接返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1]);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n    var schedule = new Map([\\n        [L, () => log(item.title + \\\"已下载100%\\\")],\\n        [~~(0.90 * L), () => log(item.title + \\\"已下载90%+\\\")],\\n        [~~(0.75 * L), () => log(item.title + \\\"已下载75%+\\\")],\\n        [~~(0.50 * L), () => log(item.title + \\\"已下载50%+\\\")],\\n        [~~(0.25 * L), () => log(item.title + \\\"已下载25%+\\\")]\\n    ]);\\n\\n    for (var i = 0; i < L; i++) {\\n        let pic = Tool.hikerPic(picList[i]);\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\".jpg\\\", pic[1]);\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\n    }\\n\\n    File.renameFile(chapterPath, order + \\\"$A$\\\" + item.title);\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\nvar $exe = {\\n    comic: comic,\\n    novel: novel\\n};\\n$.exports = function(item, info, MY_ID, order) {\\n    return $exe[info.type](item, info, MY_ID, order);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#f.通用工具\",\"path\":\"Tool.js\",\"rule\":\"$.exports = {\\n    split(text, target, count) {\\n        count = count === undefined ? 1 : count;\\n        let array = [text];\\n        for (let i = 0; i < count; i++) {\\n            text = array[i];\\n            let index = text.indexOf(target);\\n            if (index === -1) {\\n                break;\\n            }\\n            array[i] = text.slice(0, index);\\n            array[i + 1] = text.slice(index + target.length);\\n        }\\n        return array;\\n    },\\n    chunk(arr, size) {\\n        var result = [];\\n        for (var i = 0, len = arr.length; i < len; i += size) {\\n            result.push(arr.slice(i, i + size));\\n        }\\n        return result;\\n    },\\n    hikerPic(url) {\\n        var headers = {};\\n        let urls = url.split(\\\"@\\\");\\n        let picUrl = urls.shift();\\n        let length = urls.length;\\n        for (let i = 0; i < length; i++) {\\n            let [key, value] = urls[i].split(\\\"=\\\");\\n            headers[key] = value;\\n        }\\n        return [picUrl, headers];\\n    },\\n    range(start, end) {\\n        return Array(end - start).fill(0).map((el, i) => start + i);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#j.Config\",\"path\":\"Config.json\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\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: 16,\\n    def_isPaginate: \\\"1\\\", //1默认开启分页，0默认关闭\\n    viewPageSize: 200,\\n    def_Pic: \\\"hiker://images/home_pic4\\\",\\n    def_Lord_Type: \\\"comic\\\",\\n    def_View_Style: \\\"text_1\\\",\\n    def_DoVi_Style: \\\"text_2\\\",\\n    def_DoVi_Type: \\\"1\\\", //0全部, 1未完成，2已完成\\n}, localConfig);\\nconst PATHS = {\\n    novelPath: \\\"/小说/\\\",\\n    comicPath: \\\"/漫画/\\\",\\n    novelFullPath: \\\"/小说合并/\\\",\\n    externalImportPath: \\\"/外导小说/\\\"\\n}\\n\\n\\nObject.keys(PATHS).forEach(key => Config[key] = Config.homePath + PATHS[key]);\\n$.exports = Config;\"},{\"col_type\":\"movie_3\",\"name\":\"#v.主页面\",\"path\":\"Main.view\",\"rule\":\"js:\\nfunction main() {\\n    var layout = [];\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n    const Config = $.require(\\\"hiker://page/Config.json\\\");\\n    let type = getMyVar(\\\".type\\\", 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\\\" ? \\\"◉TXT\\\" : \\\"○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) => {\\n                    if (\\\"跳转小程序\\\" === input) {\\n                        return \\\"hiker://home@\\\" + it.name;\\n                    } else {\\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                    }\\n                }, it)\\n            });\\n        } else {\\n            layout.push({\\n                title: it.name,\\n                col_type: \\\"scroll_button\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule(i => {\\n                    putMyVar(\\\".tgnum\\\", i);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }, i),\\n            });\\n        }\\n    }\\n    let path = tag[tgnum].path;\\n    let mhlist = File.getFilePath(path, \\\"dir\\\");\\n\\n    if (mhlist.length === 0) {\\n        layout.push({\\n            title: \\\"““””\\\" + \\\"啥都没有耶\\\".big(),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        })\\n        return setResult(layout);\\n    }\\n    let pageUrl = type === \\\"novel\\\" ? \\\"hiker://page/NovelBrowser.view\\\" : \\\"hiker://page/ComicBrowser.view\\\";\\n    for (let item of mhlist) {\\n        let pic = fileExist(\\\"file://\\\" + item.path + \\\"/\\\" + item.name + \\\".jpg\\\") ? item.path + \\\"/\\\" + item.name + \\\".jpg\\\" : Config.def_Pic;\\n        layout.push({\\n            title: item.name,\\n            pic_url: pic,\\n            url: pageUrl + \\\"?rule=\\\" + MY_RULE.title,\\n            extra: item\\n        });\\n    }\\n    setResult(layout);\\n}\\n\\nmain();\"},{\"col_type\":\"text_1\",\"name\":\"#v.漫画章节列表\",\"path\":\"ComicBrowser.view\",\"rule\":\"js:\\nif (getParam(\\\"hasParams\\\") === \\\"true\\\") {\\n    MY_PARAMS = {\\n        path: decodeURIComponent(getParam(\\\"path\\\")),\\n        name: decodeURIComponent(getParam(\\\"name\\\"))\\n    }\\n}\\nlet path = MY_PARAMS.path;\\nsetPageTitle(\\\"CV|\\\" + MY_PARAMS.name)\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nvar layout = [];\\nlet mode = getMyVar(\\\".mode\\\", \\\"0\\\");\\nlet isReverse = getMyVar(\\\".isReverse\\\", \\\"0\\\");\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\".mode\\\");\\n    clearMyVar(\\\".isReverse\\\");\\n}));\\nconst comicStatus=new Map([[\\\"A\\\",\\\"\\\"],[\\\"B\\\",\\\"‘‘[未完成]’’\\\"]]);\\nfunction getTitle(title) {\\n    let titles = Tool.split(title, \\\"$\\\", 2);\\n    return comicStatus.get(titles[1])+titles[2] || title;\\n}\\nlayout.push({\\n    title: \\\"删除整本\\\",\\n    url: $(\\\"确认删除整本漫画？\\\").confirm((path) => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.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 = [];\\nlet lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n    let filelist = File.getFilePath(input);\\n    let piclist = filelist.map((item, i) => \\\"file://\\\" + input + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n    return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n})\\nif (mode === \\\"0\\\") {\\n    for (let item of mhlist) {\\n        array.push({\\n            title: getTitle(item.name),\\n            url: item.path+lazy,\\n            col_type: Config.def_View_Style\\n        });\\n    }\\n} else {\\n    for (let item of mhlist) {\\n        let name = getTitle(item.name);\\n        array.push({\\n            title: name,\\n            url: $(\\\"确认删除[\\\" + name + \\\"]？\\\").confirm((path) => {\\n                const File = $.require(\\\"hiker://page/File.js\\\");\\n                if (File.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 termsArr = searchTerms.split(\\\"\\\").map(t => t.replace(/\\\\*|\\\\.|\\\\?|\\\\+|\\\\$|\\\\^|\\\\[|\\\\]|\\\\(|\\\\)|\\\\{|\\\\}|\\\\||\\\\/|\\\\\\\\/g, k => \\\"\\\\\\\\\\\" + k));\\nlet reg = new RegExp(termsArr.join(\\\".*\\\"),\\\"i\\\");\\nlet pageUrl=getParam(\\\"type\\\")===\\\"novel\\\"?\\\"hiker://page/NovelBrowser.view\\\":\\\"hiker://page/ComicBrowser.view\\\";\\nfor (let sonDir of comicRuleDirs) {\\n    let comicList = File.getFilePath(sonDir.path, \\\"dir\\\");\\n    for (let comic of comicList) {\\n        if (reg.test(comic.name)) {\\n            searchResult.push({\\n                title: comic.name,\\n                pic_url: comic.path + \\\"/\\\" + comic.name + \\\".jpg\\\",\\n                url: pageUrl+\\\"?rule=\\\" + MY_RULE._title,\\n                desc: sonDir.name,\\n                extra: comic\\n            });\\n        }\\n    }\\n\\n}\\nsetResult(searchResult);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.设置\",\"path\":\"Setting.view\",\"rule\":\"js:\\nsetPageTitle(MY_RULE.title + \\\"|设置\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nlet layout = [];\\n\\nlayout.push({\\n    title: \\\"<strong>基础设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"目录路径\\\",\\n    url: \\\"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: \\\"hiker://page/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\",\\n    extra: {\\n        lver: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\",\\n        id: \\\"3559\\\"\\n    },\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"关于如何调用\\\",\\n    url: \\\"https://qun.qq.com/qqweb/qunpro/share?_wv=3&_wwv=128&inviteCode=1HFyBJ&from=246610&biz=ka\\\",\\n    desc: \\\"详细点击加入频道，频道里@LoyDgIk\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"恢复默认设置\\\",\\n    url: $(\\\"确认恢复默认设置？\\\").confirm(() => {\\n        deleteFile(\\\"config.json\\\");\\n        refreshPage(false);\\n        return \\\"toast://恢复完成\\\";\\n    }),\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"清理缓存\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRecordHistory##noHistory#?settingType=cache\\\",\\n    col_type: \\\"text_1\\\"\\n});\\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});\\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(/^\\\\s+|\\\\s+$/gm, \\\"\\\").replace(/&nbsp;/g,\\\"\\\").split(/\\\\n+/).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\\\") || \\\"{}\\\"));\\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}\\ncontent = \\\"　　\\\" + content.replace(/^\\\\s+|\\\\s+$/gm, \\\"\\\").split(/\\\\n+/).join(\\\"<br>　　\\\");\\n\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + MY_PARAMS.title + \\\"</strong>\\\").big(),\\n});\\n\\nlayout.push({\\n    title: content,\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: 18,\\n        click: true\\n    }\\n});\\nsetResult(layout);\"},{\"col_type\":\"text_1\",\"name\":\"#v.合并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.外导TXT\",\"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, undefined, \\\".txt\\\");\\n    setPageTitle(\\\"外导TXT\\\");\\n    //let layout = [];\\n    layout.push({\\n        title: \\\"导入TXT\\\",\\n        col_type: \\\"text_2\\\",\\n        url: $([\\\"系统选择器\\\", \\\"海阔选择器\\\"], 1, \\\"选择器类型\\\").select(() => {\\n            if (input === \\\"系统选择器\\\") {\\n                return \\\"fileSelect://\\\" + $.toString(() => {\\n                    if (!/(\\\\.txt)$/i.test(input)) {\\n                        toast(\\\"选择了错误的文件类型\\\");\\n                        return;\\n                    }\\n                    const Config = $.require(\\\"hiker://page/Config.json\\\");\\n                    let novelName = input.match(/\\\\/([^\\\\/]*?)(\\\\.txt)$/i)[1].replace(\\\"_fileSelect_\\\", \\\"\\\");\\n                    let topath = Config.externalImportPath + novelName + \\\".txt\\\";\\n                    let path = input.replace(\\\"file://\\\", \\\"\\\");\\n                    if (fileExist(\\\"file://\\\" + topath)) {\\n                        confirm({\\n                            title: \\\"导入提示\\\",\\n                            content: \\\"已存在[\\\" + novelName + \\\"]是否覆盖?\\\",\\n                            confirm: $.toString((path, topath) => {\\n                                const File = $.require(\\\"hiker://page/File.js\\\");\\n                                File.copyFile(path, topath, true);\\n                                if (fileExist(\\\"file://\\\" + topath + \\\".json\\\")) {\\n                                    File.deleteFiles(topath + \\\".json\\\");\\n                                }\\n                                refreshPage(false);\\n                                return \\\"toast://导入成功\\\";\\n                            }, path, topath)\\n                        });\\n                        return;\\n                    } else {\\n                        const File = $.require(\\\"hiker://page/File.js\\\");\\n                        File.copyFile(path, topath);\\n                        if (fileExist(\\\"file://\\\" + topath + \\\".json\\\")) {\\n                            File.deleteFiles(topath + \\\".json\\\");\\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 novelName = PATH.match(/\\\\/([^\\\\/]*?)(\\\\.txt)$/i)[1];\\n                        let topath = Config.externalImportPath + novelName + \\\".txt\\\";\\n                        let path = PATH;\\n                        if (fileExist(\\\"file://\\\" + topath)) {\\n                            return $(\\\"已存在[\\\" + novelName + \\\"]是否覆盖?\\\").confirm((path, topath) => {\\n                                const File = $.require(\\\"hiker://page/File.js\\\");\\n                                File.copyFile(path, topath, true);\\n                                if (fileExist(\\\"file://\\\" + topath + \\\".json\\\")) {\\n                                    File.deleteFiles(topath + \\\".json\\\");\\n                                }\\n                                back();\\n                                return \\\"toast://导入成功\\\";\\n                            }, path, topath);\\n                        } else {\\n                            const File = $.require(\\\"hiker://page/File.js\\\");\\n                            File.copyFile(path, topath);\\n                            if (fileExist(\\\"file://\\\" + topath + \\\".json\\\")) {\\n                                File.deleteFiles(topath + \\\".json\\\");\\n                            }\\n                            back();\\n                            return \\\"toast://导入成功\\\";\\n                        }\\n                    }),\\n                    requireUrl: requireUrl,\\n                    fileType: \\\".txt\\\",\\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_2\\\",\\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        col_type: \\\"line_blank\\\"\\n    });\\n\\n    function operation(path, name) {\\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                        return \\\"toast://删除成功\\\";\\n                    } else {\\n                        return \\\"toast://删除失败\\\";\\n                    }\\n                }, path);\\n                break;\\n            case \\\"阅读\\\":\\n                return \\\"hiker://page/txtParser.view\\\";\\n                break;\\n            case \\\"打开方式\\\":\\n                return \\\"openFile://file://\\\" + path;\\n                break;\\n        }\\n    }\\n\\n    for (let novel of files) {\\n        layout.push({\\n            title: novel.name,\\n            url: $(\\\"#noLoading#\\\").lazyRule(operation, novel.path, novel.name),\\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            }\\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}\\n\\n$.exports = txtView;\"},{\"col_type\":\"movie_3\",\"name\":\"#v.TXT解析器\",\"path\":\"txtParser.view\",\"rule\":\"js:\\n(function() {\\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 = MY_PARAMS.isCache;\\n    if (!path.startsWith(\\\"file://\\\")) {\\n        path = \\\"file://\\\" + path;\\n    }\\n    let layout = [];\\n    let chapterNames = [];\\n    let intervals = [];\\n    let hasPreface = false;\\n    if (fileExist(path + \\\".json\\\") && isCache) {\\n        try {\\n\\n            let c = JSON.parse(request(path + \\\".json\\\"));\\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(path + \\\".json\\\", 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+/).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}\"}],\"params\":\"{\\\"chapterList\\\":[],\\\"defaultView\\\":\\\"1\\\",\\\"info\\\":{\\\"bookName\\\":\\\"[综]用绳命推销的男人 作者：醉饮长歌\\\",\\\"bookTopPic\\\":\\\"hiker://empty\\\",\\\"parseCode\\\":\\\"(\\\\n(MY_PARAMS) => {\\\\n    var res = request(input);\\\\n    var rule = MY_PARAMS.content;\\\\n    let r = rule.content.replace(\\\\\\\"@\\\\\\\", \\\\\\\"&&\\\\\\\").replace(\\\\\\\"text\\\\\\\", \\\\\\\"Text\\\\\\\").replace(/\\\\\\\\.[0-9]/g, function (a) {\\\\n        return a.replace(\\\\\\\".\\\\\\\", \\\\\\\",\\\\\\\");\\\\n    });\\\\n    let r1 = r.split(\\\\\\\"&&\\\\\\\");\\\\n    let r2 = r1.slice(0, r1.length - 1).join(\\\\\\\"&&\\\\\\\");\\\\n    let arr = pdfa(res, \\\\\\\"body&&\\\\\\\" + r2);\\\\n    var tt = \\\\\\\"\\\\\\\";\\\\n    for (let it of arr) {\\\\n        it = it.replace(new RegExp(\\\\\\\"\\\\\\\\n\\\\\\\", \\\\\\\"g\\\\\\\"), \\\\\\\"--br--\\\\\\\");\\\\n        var t = pdfh(it, \\\\\\\"Text\\\\\\\");\\\\n        t = t.replace(new RegExp(\\\\\\\"--br--\\\\\\\", \\\\\\\"g\\\\\\\"), \\\\\\\"<br>\\\\\\\");\\\\n        if (t == \\\\\\\"\\\\\\\") {\\\\n            continue;\\\\n        }\\\\n        let t2 = t.split(\\\\\\\"<br>\\\\\\\");\\\\n        for (let it2 of t2) {\\\\n            if (it2 == \\\\\\\"\\\\\\\" || it2.length == 1) {\\\\n                continue;\\\\n            }\\\\n            if (!it2.startsWith(\\\\\\\"\\\\\\\\u3000\\\\\\\") && !it2.startsWith(\\\\\\\"&nbsp;&nbsp;\\\\\\\")) {\\\\n                it2 = \\\\\\\"&nbsp;&nbsp;&nbsp;&nbsp;\\\\\\\" + it2.trim();\\\\n            }\\\\n            if (rule.replaceRegex) {\\\\n                it2 = it2.replace(new RegExp(rule.replaceRegex.replace(\\\\\\\"##\\\\\\\", \\\\\\\"\\\\\\\"), \\\\\\\"g\\\\\\\"), \\\\\\\"\\\\\\\");\\\\n            }\\\\n            if (it2 == \\\\\\\"\\\\\\\") {\\\\n                continue;\\\\n            }\\\\n            tt += it2 + \\\\\\\"\\\\\\\\n\\\\\\\";\\\\n        }\\\\n    }\\\\n    return tt;\\\\n}\\\\n)({\\\\\\\"Toc\\\\\\\":{\\\\\\\"chapterList\\\\\\\":\\\\\\\".catalog li a\\\\\\\",\\\\\\\"chapterName\\\\\\\":\\\\\\\"text\\\\\\\",\\\\\\\"chapterUrl\\\\\\\":\\\\\\\"href\\\\\\\"},\\\\\\\"bookName\\\\\\\":\\\\\\\"[综]用绳命推销的男人 作者：醉饮长歌\\\\\\\",\\\\\\\"content\\\\\\\":{\\\\\\\"content\\\\\\\":\\\\\\\".book_con@p@text\\\\\\\",\\\\\\\"imageStyle\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"nextContentUrl\\\\\\\":\\\\\\\"text.下一页@href\\\\\\\",\\\\\\\"replaceRegex\\\\\\\":\\\\\\\"##\\\\\\\\\\\\\\\\【256文学.*\\\\\\\\\\\\\\\\】\\\\\\\"},\\\\\\\"cover\\\\\\\":\\\\\\\"hiker://empty\\\\\\\"})\\\",\\\"ruleName\\\":\\\"悦读\\\",\\\"type\\\":\\\"novel\\\"}}\",\"saved\":false,\"title\":\"本地资源管理\",\"version\":0,\"url\":\"hiker://page/download.view#noRecordHistory##noRefresh##noHistory#?rule=本地资源管理\",\"col_type\":\"text_2\",\"find_rule\":\"js:\\nconst viewConfig = Object.assign({\\n    chapterList: [],\\n    info: {},\\n    defaultView: \\\"0\\\"\\n}, MY_PARAMS);\\nviewConfig.info = Object.assign({\\n    ruleName: \\\"\\\",\\n    bookName: \\\"\\\",\\n    bookTopPic: \\\"\\\",\\n    parseCode: \\\"\\\",\\n    type: \\\"comic\\\",\\n}, viewConfig.info);\\nlet {\\n    chapterList,\\n    info,\\n    defaultView\\n} = viewConfig;\\nsetPageTitle(\\\"选择器|\\\" + info.bookName)\\n\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.json\\\");\\n\\nconst def_DoVi_Style = Config.def_DoVi_Style;\\nconst MY_ID = info.ruleName + \\\"//\\\" + info.bookName;\\n\\n\\nlet isStart = getMyVar(MY_ID + \\\":isStart\\\");\\nlet viewMode = getMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\nlet isReverse = getMyVar(MY_ID + \\\":isReverse\\\", \\\"0\\\");\\nlet tagFilter = getMyVar(MY_ID + \\\":tagFilter\\\", Config.def_DoVi_Type);\\n\\naddListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n    clearMyVar(MY_ID + \\\":loadingTeam\\\");\\n    clearMyVar(MY_ID + \\\":viewMode\\\");\\n    clearMyVar(MY_ID + \\\":completed\\\");\\n    clearMyVar(MY_ID + \\\":batchTeam\\\");\\n    clearMyVar(MY_ID + \\\":tagFilter\\\");\\n    clearMyVar(MY_ID + \\\":pageNum\\\");\\n}, MY_ID));\\n\\nlet layout = [];\\n\\nif (isStart === \\\"1\\\") {\\n    putMyVar(MY_ID + \\\":viewMode\\\", defaultView);\\n    viewMode = \\\"1\\\";\\n}\\n\\nlet backupChapterList = chapterList;\\nif (typeof chapterList === \\\"string\\\") {\\n    chapterList = JSON.parse(request(\\\"file://\\\" + chapterList) || \\\"[]\\\");\\n}\\nlet chapterAll = chapterList;\\nchapterList = chapterList.map((item, CID) => {\\n    item.CID = CID;\\n    return item;\\n});\\nlet pageNum = Number(getMyVar(MY_ID + \\\":pageNum\\\", \\\"1\\\"));\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\nchapterList = chapterChunk[pageNum] || [];\\n\\nfunction setType() {\\n    let set = (tag, put) => {\\n        putMyVar(put, tag);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    };\\n    layout.push({\\n        title: 0 == pageNum ? \\\"““””\\\" + (\\\"全部(\\\" + chapterAll.length + \\\")\\\").fontcolor(\\\"#23AD6F\\\") : \\\"全部(\\\" + chapterAll.length + \\\")\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, 0, MY_ID + \\\":pageNum\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    for (let i = 1; i < chapterChunk.length; i++) {\\n        let tagText = (i - 1) * Config.viewPageSize + \\\"-\\\" + ((i - 1) * Config.viewPageSize + chapterChunk[i].length);\\n        layout.push({\\n            title: i == pageNum ? \\\"““””\\\" + tagText.fontcolor(\\\"#23AD6F\\\") : tagText,\\n            url: $(\\\"#noLoading#\\\").lazyRule(set, i, MY_ID + \\\":pageNum\\\"),\\n            col_type: \\\"scroll_button\\\"\\n        });\\n    }\\n    layout.push({\\n        col_type: \\\"blank_block\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"0\\\" ? \\\"““””\\\" + \\\"全部\\\".fontcolor(\\\"#23AD6F\\\") : \\\"全部\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"0\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"1\\\" ? \\\"““””\\\" + \\\"未下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"未下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"1\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n    layout.push({\\n        title: tagFilter === \\\"2\\\" ? \\\"““””\\\" + \\\"已下载\\\".fontcolor(\\\"#23AD6F\\\") : \\\"已下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(set, \\\"2\\\", MY_ID + \\\":tagFilter\\\"),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n}\\nlet chapterTeam = [];\\nlet record = [];\\nif (info.type === \\\"comic\\\") {\\n    let lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        let filelist = File.getFilePath(input);\\n        let piclist = filelist.map((item, i) => \\\"file://\\\" + input + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n        return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n    });\\n\\n    function comFun(i, item) {\\n        let rootPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title;\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: rootPath + lazy,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"dir\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2]);\\n        }\\n    });\\n} else {\\n    function comFun(i, item) {\\n        return {\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i,\\n                path: Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName + \\\"/\\\" + i + \\\"$A$\\\" + item.title + \\\".txt\\\",\\n                title: item.title\\n            },\\n            col_type: def_DoVi_Style\\n        }\\n    }\\n    File.getFilePath(Config[info.type + \\\"Path\\\"] + \\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName, \\\"file\\\", \\\".txt\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\".\\\")));\\n        }\\n    });\\n}\\n\\nfunction clickDownload(item, info, MY_ID, i) {\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = loadingTeam.indexOf(i);\\n    if (ElementIndex > -1) return \\\"toast://正在下载\\\";\\n\\n    loadingTeam.push(i);\\n    putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    updateItem({\\n        title: \\\"‘‘\\\" + item.title + \\\"’’\\\",\\n        extra: {\\n            id: MY_ID + \\\"#\\\" + i\\n        }\\n    });\\n    let result = \\\"toast://下载失败\\\";\\n    try {\\n        toast(\\\"开始下载:\\\" + item.title);\\n        let download = $.require(\\\"hiker://page/Download.exe.js\\\");\\n        result = download(item, info, MY_ID, i);\\n        updateItem({\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"toast://已下载\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n    } catch (e) {\\n        updateItem({\\n            title: item.title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        log(e.toString());\\n    } finally {\\n        loadingTeam.splice(ElementIndex, 1);\\n        putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    }\\n    return result;\\n}\\n\\nfunction singleView() {\\n    layout.push({\\n        title: \\\"反转列表\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((isReverse, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, isReverse, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    layout.push({\\n        title: \\\"批量下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            if (loadingTeam.length > 0) return \\\"toast://还有任务没有完成\\\";\\n            if (getAppVersion() < 2594) return \\\"toast://未开放\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"1\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n\\n        }, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: loadingTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n}\\n\\nfunction clickChoose(title, MY_ID, i) {\\n    let isStart = getMyVar(MY_ID + \\\":isStart\\\");\\n    if (isStart === \\\"1\\\") return \\\"toast://正在下载...\\\";\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = batchTeam.indexOf(i);\\n    if (ElementIndex > -1) {\\n        updateItem({\\n            title: title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.splice(ElementIndex, 1);\\n    } else {\\n        updateItem({\\n            title: \\\"‘‘\\\" + title + \\\"’’\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.push(i);\\n    }\\n    putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n    return \\\"hiker://empty\\\";\\n}\\n\\nfunction batchView() {\\n    layout.push({\\n        title: \\\"单选下载\\\",\\n        pic_url: \\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在批量下载\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"0\\\");\\n            clearMyVar(MY_ID + \\\":batchTeam\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\n    let end = start + chapterList.length;\\n    layout.push({\\n        title: \\\"选择全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = Tool.range(start, end);\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\":completed\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"取消全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = new Set(Tool.range(start, end));\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"确认选中\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\", \\\"-1\\\") !== \\\"-1\\\") {\\n                return \\\"toast://正在下载...\\\";\\n            }\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            return batchTeam.length === 0 ? \\\"toast://你还什么都没有选\\\" : \\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\";\\n        }, MY_ID),\\n        extra: {\\n            newWindow: true,\\n            windowId: MY_ID + \\\"//批量下载\\\",\\n            MY_ID: MY_ID,\\n            chapterList: backupChapterList,\\n            info: info\\n        },\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let completed = [];\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            completed.push(item.CID);\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: batchTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n    putMyVar(MY_ID + \\\":completed\\\", JSON.stringify(completed));\\n}\\nswitch (viewMode) {\\n    case \\\"0\\\":\\n        singleView();\\n        break;\\n    case \\\"1\\\":\\n        batchView();\\n        break;\\n}\\nif (isReverse === \\\"1\\\") {\\n    chapterTeam.reverse();\\n}\\nlayout.push.apply(layout, chapterTeam);\\nsetResult(layout);\",\"group\":\"①推荐\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#f.File工具\\\",\\\"path\\\":\\\"File.js\\\",\\\"rule\\\":\\\"const File = java.io.File;\\\\nconst {\\\\n    Files,\\\\n    Paths,\\\\n    StandardCopyOption,\\\\n    StandardOpenOption\\\\n} = java.nio.file;\\\\nconst javaString = java.lang.String;\\\\nlet javaScope = new JavaImporter(java.io, java.lang, java.lang.reflect, java.util.Vector);\\\\n\\\\nfunction 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    }\\\\n    if (expand) {\\\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\\\n    }\\\\n    return pathList;\\\\n}\\\\n\\\\nfunction renameFile(fromPath, name) {\\\\n    let fromFile = new File(fromPath);\\\\n    let toFile = new File(fromFile.getParent() + \\\\\\\"/\\\\\\\" + name);\\\\n    try {\\\\n        if (!fromFile.exists()) {\\\\n            return false;\\\\n        }\\\\n        if (toFile.exists()) {\\\\n            if (!deleteFlies(toPath)) {\\\\n                return false;\\\\n            }\\\\n        }\\\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\\\n        return true;\\\\n    } catch (e) {\\\\n        log(e.toString());\\\\n        return false;\\\\n    }\\\\n}\\\\n\\\\nfunction moveFiles(fromPath, toPath) {\\\\n    let fromFile = new File(fromPath);\\\\n    let toFile = new File(toPath);\\\\n    try {\\\\n        if (!fromFile.exists()) {\\\\n            return false;\\\\n        }\\\\n        if (toFile.exists()) {\\\\n            if (!deleteFlies(toPath)) {\\\\n                return false;\\\\n            }\\\\n        }\\\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\\\n        return true;\\\\n    } catch (e) {\\\\n        log(e.toString());\\\\n        return false;\\\\n    }\\\\n}\\\\n\\\\nfunction fileWrite(path, content) {\\\\n    writeFile(\\\\\\\"file://\\\\\\\" + path, content)\\\\n}\\\\n\\\\nfunction fileWriteAppend(path, content) {\\\\n    let file = new File(path);\\\\n    let paths = file.toPath();\\\\n    if (file.exists()) {\\\\n        Files.write(paths, new javaString(content).getBytes(), StandardOpenOption.APPEND);\\\\n    } else {\\\\n        writeFile(\\\\\\\"file://\\\\\\\" + path, content);\\\\n    }\\\\n}\\\\n\\\\nfunction getTotalSizeOfFilesInDir(file) {\\\\n    if (file.isFile()) {\\\\n        return file.length();\\\\n    }\\\\n    let children = file.listFiles();\\\\n    let total = 0;\\\\n    if (children != null) {\\\\n        for (let child of children) {\\\\n            total += getTotalSizeOfFilesInDir(child);\\\\n        }\\\\n    }\\\\n    return total;\\\\n}\\\\n\\\\nfunction getFileSize(filePath) {\\\\n    //Byte\\\\n    let size = getTotalSizeOfFilesInDir(new File(filePath));\\\\n    if (size < 0) {\\\\n        return null;\\\\n    }\\\\n    let unitForm = [\\\\\\\"Byte\\\\\\\", \\\\\\\"KB\\\\\\\", \\\\\\\"MB\\\\\\\", \\\\\\\"GB\\\\\\\", \\\\\\\"TB\\\\\\\"];\\\\n    for (let i = 0, len = unitForm.length; i < len; i++) {\\\\n        if (size > 1024) {\\\\n            size /= 1024;\\\\n            continue;\\\\n        } else {\\\\n            return 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}\\\"},{\\\"col_type\\\":\\\"text_2\\\",\\\"name\\\":\\\"#v.下载列表-普通下载\\\",\\\"path\\\":\\\"download.view\\\",\\\"rule\\\":\\\"js:\\\\nconst viewConfig = Object.assign({\\\\n    chapterList: [],\\\\n    info: {},\\\\n    defaultView: \\\\\\\"0\\\\\\\"\\\\n}, MY_PARAMS);\\\\nviewConfig.info = Object.assign({\\\\n    ruleName: \\\\\\\"\\\\\\\",\\\\n    bookName: \\\\\\\"\\\\\\\",\\\\n    bookTopPic: \\\\\\\"\\\\\\\",\\\\n    parseCode: \\\\\\\"\\\\\\\",\\\\n    type: \\\\\\\"comic\\\\\\\",\\\\n}, viewConfig.info);\\\\nlet {\\\\n    chapterList,\\\\n    info,\\\\n    defaultView\\\\n} = viewConfig;\\\\nsetPageTitle(\\\\\\\"选择器|\\\\\\\" + info.bookName)\\\\n\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nconst def_DoVi_Style = Config.def_DoVi_Style;\\\\nconst MY_ID = info.ruleName + \\\\\\\"//\\\\\\\" + info.bookName;\\\\n\\\\n\\\\nlet isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\nlet viewMode = getMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", defaultView);\\\\nlet isReverse = getMyVar(MY_ID + \\\\\\\":isReverse\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet tagFilter = getMyVar(MY_ID + \\\\\\\":tagFilter\\\\\\\", Config.def_DoVi_Type);\\\\n\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString((MY_ID) => {\\\\n    clearMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":completed\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":tagFilter\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":pageNum\\\\\\\");\\\\n}, MY_ID));\\\\n\\\\nlet layout = [];\\\\n\\\\nif (isStart === \\\\\\\"1\\\\\\\") {\\\\n    putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", defaultView);\\\\n    viewMode = \\\\\\\"1\\\\\\\";\\\\n}\\\\n\\\\nlet backupChapterList = chapterList;\\\\nif (typeof chapterList === \\\\\\\"string\\\\\\\") {\\\\n    chapterList = JSON.parse(request(\\\\\\\"file://\\\\\\\" + chapterList) || \\\\\\\"[]\\\\\\\");\\\\n}\\\\nlet chapterAll = chapterList;\\\\nchapterList = chapterList.map((item, CID) => {\\\\n    item.CID = CID;\\\\n    return item;\\\\n});\\\\nlet pageNum = Number(getMyVar(MY_ID + \\\\\\\":pageNum\\\\\\\", \\\\\\\"1\\\\\\\"));\\\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\\\nchapterList = chapterChunk[pageNum] || [];\\\\n\\\\nfunction setType() {\\\\n    let set = (tag, put) => {\\\\n        putMyVar(put, tag);\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    };\\\\n    layout.push({\\\\n        title: 0 == pageNum ? \\\\\\\"““””\\\\\\\" + (\\\\\\\"全部(\\\\\\\" + chapterAll.length + \\\\\\\")\\\\\\\").fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"全部(\\\\\\\" + chapterAll.length + \\\\\\\")\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, 0, MY_ID + \\\\\\\":pageNum\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n    for (let i = 1; i < chapterChunk.length; i++) {\\\\n        let tagText = (i - 1) * Config.viewPageSize + \\\\\\\"-\\\\\\\" + ((i - 1) * Config.viewPageSize + chapterChunk[i].length);\\\\n        layout.push({\\\\n            title: i == pageNum ? \\\\\\\"““””\\\\\\\" + tagText.fontcolor(\\\\\\\"#23AD6F\\\\\\\") : tagText,\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, i, MY_ID + \\\\\\\":pageNum\\\\\\\"),\\\\n            col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n        });\\\\n    }\\\\n    layout.push({\\\\n        col_type: \\\\\\\"blank_block\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: tagFilter === \\\\\\\"0\\\\\\\" ? \\\\\\\"““””\\\\\\\" + \\\\\\\"全部\\\\\\\".fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"全部\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, \\\\\\\"0\\\\\\\", MY_ID + \\\\\\\":tagFilter\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: tagFilter === \\\\\\\"1\\\\\\\" ? \\\\\\\"““””\\\\\\\" + \\\\\\\"未下载\\\\\\\".fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"未下载\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, \\\\\\\"1\\\\\\\", MY_ID + \\\\\\\":tagFilter\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: tagFilter === \\\\\\\"2\\\\\\\" ? \\\\\\\"““””\\\\\\\" + \\\\\\\"已下载\\\\\\\".fontcolor(\\\\\\\"#23AD6F\\\\\\\") : \\\\\\\"已下载\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(set, \\\\\\\"2\\\\\\\", MY_ID + \\\\\\\":tagFilter\\\\\\\"),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    });\\\\n}\\\\nlet chapterTeam = [];\\\\nlet record = [];\\\\nif (info.type === \\\\\\\"comic\\\\\\\") {\\\\n    let lazy = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        let filelist = File.getFilePath(input);\\\\n        let piclist = filelist.map((item, i) => \\\\\\\"file://\\\\\\\" + input + \\\\\\\"/\\\\\\\" + (i + 1) + \\\\\\\".jpg\\\\\\\");\\\\n        return \\\\\\\"pics://\\\\\\\" + piclist.join(\\\\\\\"&&\\\\\\\");\\\\n    });\\\\n\\\\n    function comFun(i, item) {\\\\n        let rootPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\" + i + \\\\\\\"$A$\\\\\\\" + item.title;\\\\n        return {\\\\n            title: \\\\\\\"““\\\\\\\" + item.title + \\\\\\\"””\\\\\\\",\\\\n            url: rootPath + lazy,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i,\\\\n            },\\\\n            col_type: def_DoVi_Style\\\\n        }\\\\n    }\\\\n    File.getFilePath(Config[info.type + \\\\\\\"Path\\\\\\\"] + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName, \\\\\\\"dir\\\\\\\").forEach((file) => {\\\\n        let att = Tool.split(file.name, \\\\\\\"$\\\\\\\", 2);\\\\n        if (att.length === 3 && att[1] === (\\\\\\\"A\\\\\\\")) {\\\\n            record.push(att[2]);\\\\n        }\\\\n    });\\\\n} else {\\\\n    function comFun(i, item) {\\\\n        return {\\\\n            title: \\\\\\\"““\\\\\\\" + item.title + \\\\\\\"””\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/NovelMainBody#autoPage##readTheme#\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i,\\\\n                path: Config.novelPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\" + i + \\\\\\\"$A$\\\\\\\" + item.title + \\\\\\\".txt\\\\\\\",\\\\n                title: item.title\\\\n            },\\\\n            col_type: def_DoVi_Style\\\\n        }\\\\n    }\\\\n    File.getFilePath(Config[info.type + \\\\\\\"Path\\\\\\\"] + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName, \\\\\\\"file\\\\\\\", \\\\\\\".txt\\\\\\\").forEach((file) => {\\\\n        let att = Tool.split(file.name, \\\\\\\"$\\\\\\\", 2);\\\\n        if (att.length === 3 && att[1] === (\\\\\\\"A\\\\\\\")) {\\\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\\\\\".\\\\\\\")));\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nfunction clickDownload(item, info, MY_ID, i) {\\\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let ElementIndex = loadingTeam.indexOf(i);\\\\n    if (ElementIndex > -1) return \\\\\\\"toast://正在下载\\\\\\\";\\\\n\\\\n    loadingTeam.push(i);\\\\n    putMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", JSON.stringify(loadingTeam));\\\\n    updateItem({\\\\n        title: \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n        }\\\\n    });\\\\n    let result = \\\\\\\"toast://下载失败\\\\\\\";\\\\n    try {\\\\n        toast(\\\\\\\"开始下载:\\\\\\\" + item.title);\\\\n        let download = $.require(\\\\\\\"hiker://page/Download.exe.js\\\\\\\");\\\\n        result = download(item, info, MY_ID, i);\\\\n        updateItem({\\\\n            title: \\\\\\\"““\\\\\\\" + item.title + \\\\\\\"””\\\\\\\",\\\\n            url: \\\\\\\"toast://已下载\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n    } catch (e) {\\\\n        updateItem({\\\\n            title: item.title,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        log(e.toString());\\\\n    } finally {\\\\n        loadingTeam.splice(ElementIndex, 1);\\\\n        putMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", JSON.stringify(loadingTeam));\\\\n    }\\\\n    return result;\\\\n}\\\\n\\\\nfunction singleView() {\\\\n    layout.push({\\\\n        title: \\\\\\\"反转列表\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReverse, MY_ID) => {\\\\n            putMyVar(MY_ID + \\\\\\\":isReverse\\\\\\\", isReverse === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, isReverse, MY_ID),\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\\\\\",\\\\n        col_type: \\\\\\\"icon_2\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"批量下载\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            if (loadingTeam.length > 0) return \\\\\\\"toast://还有任务没有完成\\\\\\\";\\\\n            if (getAppVersion() < 2594) return \\\\\\\"toast://未开放\\\\\\\";\\\\n            putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n        }, MY_ID),\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\\\\\",\\\\n        col_type: \\\\\\\"icon_2\\\\\\\"\\\\n    });\\\\n    setType();\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\\\n        let is_download = record.includes(item.title);\\\\n        if (is_download && tagFilter !== \\\\\\\"1\\\\\\\") {\\\\n            chapterTeam.push(comFun(item.CID, item));\\\\n        } else if (!is_download && tagFilter !== \\\\\\\"2\\\\\\\") {\\\\n            chapterTeam.push({\\\\n                title: loadingTeam.includes(item.CID) ? \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\" : item.title,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"#\\\\\\\" + item.CID\\\\n                },\\\\n                col_type: def_DoVi_Style\\\\n            });\\\\n        }\\\\n    }\\\\n}\\\\n\\\\nfunction clickChoose(title, MY_ID, i) {\\\\n    let isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n    if (isStart === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在下载...\\\\\\\";\\\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let ElementIndex = batchTeam.indexOf(i);\\\\n    if (ElementIndex > -1) {\\\\n        updateItem({\\\\n            title: title,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        batchTeam.splice(ElementIndex, 1);\\\\n    } else {\\\\n        updateItem({\\\\n            title: \\\\\\\"‘‘\\\\\\\" + title + \\\\\\\"’’\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        batchTeam.push(i);\\\\n    }\\\\n    putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n}\\\\n\\\\nfunction batchView() {\\\\n    layout.push({\\\\n        title: \\\\\\\"单选下载\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\") === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在批量下载\\\\\\\";\\\\n            putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\\\n    let end = start + chapterList.length;\\\\n    layout.push({\\\\n        title: \\\\\\\"选择全部\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((start, end, MY_ID) => {\\\\n            const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n            let chooseTeam = Tool.range(start, end);\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\\\\\":completed\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, start, end, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"取消全部\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((start, end, MY_ID) => {\\\\n            const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n            let chooseTeam = new Set(Tool.range(start, end));\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, start, end, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"确认选中\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"-1\\\\\\\") !== \\\\\\\"-1\\\\\\\") {\\\\n                return \\\\\\\"toast://正在下载...\\\\\\\";\\\\n            }\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            return batchTeam.length === 0 ? \\\\\\\"toast://你还什么都没有选\\\\\\\" : \\\\\\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\\\\\";\\\\n        }, MY_ID),\\\\n        extra: {\\\\n            newWindow: true,\\\\n            windowId: MY_ID + \\\\\\\"//批量下载\\\\\\\",\\\\n            MY_ID: MY_ID,\\\\n            chapterList: backupChapterList,\\\\n            info: info\\\\n        },\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    setType();\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let completed = [];\\\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\\\n        let is_download = record.includes(item.title);\\\\n        if (is_download && tagFilter !== \\\\\\\"1\\\\\\\") {\\\\n            completed.push(item.CID);\\\\n            chapterTeam.push(comFun(item.CID, item));\\\\n        } else if (!is_download && tagFilter !== \\\\\\\"2\\\\\\\") {\\\\n            chapterTeam.push({\\\\n                title: batchTeam.includes(item.CID) ? \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\" : item.title,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"#\\\\\\\" + item.CID\\\\n                },\\\\n                col_type: def_DoVi_Style\\\\n            });\\\\n        }\\\\n    }\\\\n    putMyVar(MY_ID + \\\\\\\":completed\\\\\\\", JSON.stringify(completed));\\\\n}\\\\nswitch (viewMode) {\\\\n    case \\\\\\\"0\\\\\\\":\\\\n        singleView();\\\\n        break;\\\\n    case \\\\\\\"1\\\\\\\":\\\\n        batchView();\\\\n        break;\\\\n}\\\\nif (isReverse === \\\\\\\"1\\\\\\\") {\\\\n    chapterTeam.reverse();\\\\n}\\\\nlayout.push.apply(layout, chapterTeam);\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.批量下载器\\\",\\\"path\\\":\\\"Batch.view\\\",\\\"rule\\\":\\\"js:\\\\nlet {\\\\n    chapterList,\\\\n    info,\\\\n    MY_ID\\\\n} = MY_PARAMS;\\\\nsetPageTitle(\\\\\\\"下载器|\\\\\\\"+info.bookName);\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString((MY_ID) => {\\\\n    clearMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":status\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n    refreshPage();\\\\n}, MY_ID));\\\\n\\\\nlet isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet layout = [];\\\\n\\\\nlet batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\nif(typeof chapterList === \\\\\\\"string\\\\\\\"){\\\\n    chapterList = JSON.parse(request(\\\\\\\"file://\\\\\\\"+chapterList)||\\\\\\\"[]\\\\\\\");\\\\n}\\\\nlet chapterTeam = batchTeam.map(v => {\\\\n    let chapterItem = chapterList[v];\\\\n    chapterItem.CID = v;\\\\n    return chapterItem;\\\\n});\\\\nif (isStart === \\\\\\\"0\\\\\\\") {\\\\n    layout.push({\\\\n        title: \\\\\\\"开始下载[\\\\\\\" + chapterTeam.length + \\\\\\\"]\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((chapterTeam, info, MY_ID) => {\\\\n            putMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage(false);\\\\n            let download = $.require(\\\\\\\"hiker://page/BatchStatistics.js\\\\\\\");\\\\n            return download(chapterTeam, info, MY_ID) || \\\\\\\"toast://下载错误\\\\\\\";\\\\n        }, chapterTeam, info, MY_ID),\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||开始下载\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"任务列表：\\\\\\\",\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    });\\\\n    for (let item of chapterTeam) {\\\\n        layout.push({\\\\n            title: item.title,\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_2\\\\\\\"\\\\n        });\\\\n    }\\\\n\\\\n} else {\\\\n    layout.push({\\\\n        title: \\\\\\\"下载进度:0/\\\\\\\"+chapterTeam.length,\\\\n        desc: \\\\\\\"““””▇▇▇▇▇▇▇▇▇▇\\\\\\\".fontcolor(\\\\\\\"#e5e1e4\\\\\\\")+\\\\\\\" 0%\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||下载进度\\\\\\\",\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"后台下载\\\\\\\",\\\\n        url: \\\\\\\"func://background\\\\\\\",\\\\n        col_type: \\\\\\\"text_2\\\\\\\"\\\\n    });\\\\n\\\\n    layout.push({\\\\n        title: [\\\\\\\"[取消下载]\\\\\\\", \\\\\\\"[正在停止...]\\\\\\\", \\\\\\\"[返回]\\\\\\\", \\\\\\\"[处理失败]\\\\\\\", \\\\\\\"[重新开始]\\\\\\\"][status],\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            if (status === \\\\\\\"0\\\\\\\") {\\\\n                putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n                updateItem({\\\\n                    title: \\\\\\\"[正在停止...]\\\\\\\",\\\\n                    extra: {\\\\n                        id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                    }\\\\n                });\\\\n                return \\\\\\\"toast://正在取消下载任务\\\\\\\";\\\\n            } else if (status === \\\\\\\"1\\\\\\\") {\\\\n                return \\\\\\\"toast://正在暂停...\\\\\\\";\\\\n            } else if (status === \\\\\\\"2\\\\\\\") {\\\\n                back();\\\\n                return \\\\\\\"toast://已退出下载器\\\\\\\";\\\\n            } else if ([\\\\\\\"3\\\\\\\", \\\\\\\"4\\\\\\\"].includes(status)) {\\\\n                clearMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n                clearMyVar(MY_ID + \\\\\\\":status\\\\\\\");\\\\n                clearMyVar(MY_ID + \\\\\\\":log\\\\\\\");\\\\n                refreshPage();\\\\n                return \\\\\\\"toast://重新点击下载\\\\\\\"\\\\n            }\\\\n        }, MY_ID),\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"<strong>下载日志</strong>\\\\\\\".big(),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n        \\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||日志\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title:\\\\\\\"““””$>\\\\\\\"+\\\\\\\"开始下载......\\\\\\\".fontcolor(\\\\\\\"#00ff00\\\\\\\"),\\\\n        url:\\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"#log#0\\\\\\\",\\\\n            lineVisible:false\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.批量下载统计\\\",\\\"path\\\":\\\"BatchStatistics.js\\\",\\\"rule\\\":\\\"const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nfunction task(taskParam) {\\\\n    let result = $.require(\\\\\\\"hiker://page/Batch.exe.js\\\\\\\")(taskParam);\\\\n    return result;\\\\n}\\\\n\\\\n$.exports = function(chapterTeam, info, MY_ID) {\\\\n    if (chapterTeam.length === 0) {\\\\n        return \\\\\\\"toast://空的下载队列\\\\\\\";\\\\n    }\\\\n    var count = 0;\\\\n    var taskCount = chapterTeam.length;\\\\n    var successCID = [];\\\\n    var failName = [];\\\\n    var logCount = 1;\\\\n    var taskTeam = chapterTeam.map(chapterItem => ({\\\\n        func: task,\\\\n        id: chapterItem.title,\\\\n        param: {\\\\n            chapterItem: chapterItem,\\\\n            info: info,\\\\n            MY_ID: MY_ID\\\\n        }\\\\n    }));\\\\n    let logNum = Config.logNum;\\\\n\\\\n    function putLog(text) {\\\\n        log(text);\\\\n        if (logCount >= logNum) {\\\\n            deleteItem(MY_ID + \\\\\\\"#log#\\\\\\\" + (logCount - 10));\\\\n        }\\\\n        addItemAfter(MY_ID + \\\\\\\"||日志\\\\\\\", {\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            title: \\\\\\\"$>\\\\\\\" + text,\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false,\\\\n                id: MY_ID + \\\\\\\"#log#\\\\\\\" + logCount\\\\n            }\\\\n        });\\\\n        logCount++;\\\\n    }\\\\n\\\\n    function listener(perch, id, error, CID) {\\\\n        count++;\\\\n        let isSuccess = false;\\\\n        if (error !== null) {\\\\n            failName.push(id);\\\\n            putLog(\\\\\\\"[listener]下载失败：\\\\\\\" + id + \\\\\\\"<ERROR@ \\\\\\\" + error + \\\\\\\">\\\\\\\");\\\\n        } else if (CID >= 0) {\\\\n            successCID.push(CID);\\\\n            let ratio = (count / taskCount).toFixed(4);\\\\n            let stripCount = Math.ceil(ratio * 10);\\\\n            isSuccess = true;\\\\n            updateItem({\\\\n                title: \\\\\\\"下载进度：\\\\\\\" + successCID.length + \\\\\\\"/\\\\\\\" + taskCount,\\\\n                desc: \\\\\\\"““””\\\\\\\" + \\\\\\\"▇\\\\\\\".repeat(stripCount).fontcolor(\\\\\\\"#ffac2d\\\\\\\") + \\\\\\\"▇\\\\\\\".repeat(10 - stripCount).fontcolor(\\\\\\\"#e5e1e4\\\\\\\") + \\\\\\\" \\\\\\\" + (ratio * 100) + \\\\\\\"%\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载进度\\\\\\\"\\\\n                }\\\\n            });\\\\n            putLog(\\\\\\\"[listener]已完成下载：\\\\\\\" + id);\\\\n        } else if (CID === -1) {\\\\n            failName.push(id);\\\\n            putLog(\\\\\\\"[listener]已停止：\\\\\\\" + id);\\\\n        }\\\\n        if (taskCount !== count) return;\\\\n        if (successCID.length === taskCount) {\\\\n            updateItem({\\\\n                desc: \\\\\\\"““””\\\\\\\" + \\\\\\\"▇\\\\\\\".repeat(10).fontcolor(\\\\\\\"#00ff00\\\\\\\") + \\\\\\\" 100%\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载进度\\\\\\\"\\\\n                }\\\\n            });\\\\n        }\\\\n        let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n        let failTeam = batchTeam.filter(v => !successCID.includes(v));\\\\n        putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(failTeam));\\\\n        if (failTeam.length > 0 && status !== \\\\\\\"1\\\\\\\") {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"3\\\\\\\");\\\\n            putLog(\\\\\\\"下载失败:[\\\\\\\" + failName.join(\\\\\\\"]，[\\\\\\\") + \\\\\\\"]。\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[处理失败]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        } else if (failTeam.length > 0 && status === \\\\\\\"1\\\\\\\") {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"4\\\\\\\");\\\\n            putLog(\\\\\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[重新开始]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        } else {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"2\\\\\\\");\\\\n            putLog(\\\\\\\"下载任务[\\\\\\\" + info.bookName + \\\\\\\"]已全部成功完成\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[返回]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        }\\\\n        toast(\\\\\\\"下载任务[\\\\\\\" + info.bookName + \\\\\\\"]已完成\\\\\\\");\\\\n    }\\\\n    let taskTeamChunk = [];\\\\n    if (Config.threadNum > 0) {\\\\n        taskTeamChunk = Tool.chunk(taskTeam, Config.threadNum);\\\\n    } else {\\\\n        taskTeamChunk = [taskTeam];\\\\n    }\\\\n    for (let taskList of taskTeamChunk) {\\\\n        be(taskList, {\\\\n            func: listener\\\\n        });\\\\n        let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n        if (status === \\\\\\\"1\\\\\\\") {\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            let failTeam = batchTeam.filter(v => !successCID.includes(v));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(failTeam));\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"4\\\\\\\");\\\\n            putLog(\\\\\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[重新开始]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }\\\\n\\\\n    }\\\\n\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.批量主程序\\\",\\\"path\\\":\\\"Batch.exe.js\\\",\\\"rule\\\":\\\"const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n\\\\nfunction comic(taskParam) {\\\\n    let {\\\\n        chapterItem,\\\\n        info,\\\\n        MY_ID,\\\\n    } = taskParam;\\\\n    if (getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n        return -1;\\\\n    }\\\\n    let mainPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + chapterItem.CID + \\\\\\\"$B$\\\\\\\" + chapterItem.title + \\\\\\\"/\\\\\\\";\\\\n    let picList;\\\\n    try {\\\\n        let getPicList = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"return \\\\\\\" + info.parseCode);\\\\n        picList = getPicList(chapterItem.url, chapterItem.url);\\\\n        if (typeof picList === \\\\\\\"string\\\\\\\") {\\\\n            picList = picList.replace(\\\\\\\"pics://\\\\\\\", \\\\\\\"\\\\\\\").split(\\\\\\\"&&\\\\\\\");\\\\n        }\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<漫画图片解析错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\";\\\\n        throw e;\\\\n    }\\\\n    const L = picList.length;\\\\n    if(L===0){\\\\n        throw new Error(\\\\\\\"<漫画图片解析错误：图片链接返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\");\\\\n        }\\\\n    }\\\\n    var schedule = new Map([\\\\n        [L, () => log(chapterItem.title + \\\\\\\"已下载100%\\\\\\\")],\\\\n        [~~(0.90 * L), () => log(chapterItem.title + \\\\\\\"已下载90%+\\\\\\\")],\\\\n        [~~(0.75 * L), () => log(chapterItem.title + \\\\\\\"已下载75%+\\\\\\\")],\\\\n        [~~(0.50 * L), () => log(chapterItem.title + \\\\\\\"已下载50%+\\\\\\\")],\\\\n        [~~(0.25 * L), () => log(chapterItem.title + \\\\\\\"已下载25%+\\\\\\\")]\\\\n    ]);\\\\n    for (var i = 0; i < L; i++) {\\\\n        let pic = Tool.hikerPic(picList[i]);\\\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\\\\\".jpg\\\\\\\", pic[1]);\\\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\\\n        if (getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n            return -1;\\\\n        }\\\\n    }\\\\n    File.renameFile(chapterPath, chapterItem.CID + \\\\\\\"$A$\\\\\\\" + chapterItem.title);\\\\n    return chapterItem.CID;\\\\n}\\\\n\\\\nfunction novel(taskParam) {\\\\n    let {\\\\n        chapterItem,\\\\n        info,\\\\n        MY_ID,\\\\n    } = taskParam;\\\\n    if (getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n        return -1;\\\\n    }\\\\n    let mainPath = Config.novelPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + chapterItem.CID + \\\\\\\"$A$\\\\\\\" + chapterItem.title + \\\\\\\".txt\\\\\\\";\\\\n    let content = \\\\\\\"\\\\\\\";\\\\n    try {\\\\n        let getContent = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"return \\\\\\\" + info.parseCode);\\\\n        content = getContent(chapterItem.url, chapterItem.url);\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<小说正文解析错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\";\\\\n        throw e;\\\\n    }\\\\n    if (!content) {\\\\n        throw new Error(\\\\\\\"<小说正文解析错误：正文返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误：\\\\\\\" + e.message + \\\\\\\">\\\\\\\");\\\\n        }\\\\n    }\\\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\\\\\/script>/gmi, \\\\\\\"\\\\\\\").trimRight());\\\\n    //File.renameFile(chapterPath, chapterItem.CID + \\\\\\\"$A$\\\\\\\" + chapterItem.title);\\\\n    return chapterItem.CID;\\\\n}\\\\nvar $exe = {\\\\n    comic: comic,\\\\n    novel: novel\\\\n};\\\\n$.exports = function(taskParam) {\\\\n    return $exe[taskParam.info.type](taskParam);\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.普通主程序\\\",\\\"path\\\":\\\"Download.exe.js\\\",\\\"rule\\\":\\\"const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n\\\\nfunction novel(item, info, MY_ID, order) {\\\\n    let mainPath = Config.novelPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + order + \\\\\\\"$A$\\\\\\\" + item.title + \\\\\\\".txt\\\\\\\";\\\\n    let content = \\\\\\\"\\\\\\\";\\\\n    try {\\\\n        let getContent = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"return \\\\\\\" + info.parseCode);\\\\n        content = getContent(item.url, item.url) || \\\\\\\"\\\\\\\";\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<小说正文解析错误> \\\\\\\" + e.message;\\\\n        throw e;\\\\n    }\\\\n    if (!content) {\\\\n        toast(\\\\\\\"小说为空\\\\\\\");\\\\n        throw new Error(\\\\\\\"<小说正文解析错误：正文返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误> \\\\\\\" + e.message);\\\\n        }\\\\n    }\\\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\\\\\/script>/gmi, \\\\\\\"\\\\\\\").trimRight());\\\\n    //File.renameFile(chapterPath, order + \\\\\\\"$A$\\\\\\\" + item.title + \\\\\\\".txt\\\\\\\");\\\\n    return \\\\\\\"toast://\\\\\\\" + info.bookName + \\\\\\\"@\\\\\\\" + item.title + \\\\\\\" 下载完成\\\\\\\";\\\\n}\\\\n\\\\nfunction comic(item, info, MY_ID, order) {\\\\n    let mainPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + order + \\\\\\\"$B$\\\\\\\" + item.title + \\\\\\\"/\\\\\\\";\\\\n    let picList = [];\\\\n    try {\\\\n        let getPicList = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"return\\\\\\\" + info.parseCode);\\\\n        picList = getPicList(item.url);\\\\n        if (typeof picList === \\\\\\\"string\\\\\\\") {\\\\n            picList = picList.replace(\\\\\\\"pics://\\\\\\\", \\\\\\\"\\\\\\\").split(\\\\\\\"&&\\\\\\\");\\\\n        }\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<漫画图片解析错误> \\\\\\\" + e.message;\\\\n        throw e;\\\\n    }\\\\n\\\\n    const L = picList.length;\\\\n    if(L===0){\\\\n        toast(\\\\\\\"图片链接为空\\\\\\\");\\\\n        throw new Error(\\\\\\\"<漫画图片解析错误：图片链接返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            requireDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1]);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误> \\\\\\\" + e.message);\\\\n        }\\\\n    }\\\\n    var schedule = new Map([\\\\n        [L, () => log(item.title + \\\\\\\"已下载100%\\\\\\\")],\\\\n        [~~(0.90 * L), () => log(item.title + \\\\\\\"已下载90%+\\\\\\\")],\\\\n        [~~(0.75 * L), () => log(item.title + \\\\\\\"已下载75%+\\\\\\\")],\\\\n        [~~(0.50 * L), () => log(item.title + \\\\\\\"已下载50%+\\\\\\\")],\\\\n        [~~(0.25 * L), () => log(item.title + \\\\\\\"已下载25%+\\\\\\\")]\\\\n    ]);\\\\n\\\\n    for (var i = 0; i < L; i++) {\\\\n        let pic = Tool.hikerPic(picList[i]);\\\\n        requireDownload(pic[0], chapterPath + (i + 1) + \\\\\\\".jpg\\\\\\\", pic[1]);\\\\n        schedule.has(i + 1) && schedule.get(i + 1)();\\\\n    }\\\\n\\\\n    File.renameFile(chapterPath, order + \\\\\\\"$A$\\\\\\\" + item.title);\\\\n    return \\\\\\\"toast://\\\\\\\" + info.bookName + \\\\\\\"@\\\\\\\" + item.title + \\\\\\\" 下载完成\\\\\\\";\\\\n}\\\\nvar $exe = {\\\\n    comic: comic,\\\\n    novel: novel\\\\n};\\\\n$.exports = function(item, info, MY_ID, order) {\\\\n    return $exe[info.type](item, info, MY_ID, order);\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#f.通用工具\\\",\\\"path\\\":\\\"Tool.js\\\",\\\"rule\\\":\\\"$.exports = {\\\\n    split(text, target, count) {\\\\n        count = count === undefined ? 1 : count;\\\\n        let array = [text];\\\\n        for (let i = 0; i < count; i++) {\\\\n            text = array[i];\\\\n            let index = text.indexOf(target);\\\\n            if (index === -1) {\\\\n                break;\\\\n            }\\\\n            array[i] = text.slice(0, index);\\\\n            array[i + 1] = text.slice(index + target.length);\\\\n        }\\\\n        return array;\\\\n    },\\\\n    chunk(arr, size) {\\\\n        var result = [];\\\\n        for (var i = 0, len = arr.length; i < len; i += size) {\\\\n            result.push(arr.slice(i, i + size));\\\\n        }\\\\n        return result;\\\\n    },\\\\n    hikerPic(url) {\\\\n        var headers = {};\\\\n        let urls = url.split(\\\\\\\"@\\\\\\\");\\\\n        let picUrl = urls.shift();\\\\n        let length = urls.length;\\\\n        for (let i = 0; i < length; i++) {\\\\n            let [key, value] = urls[i].split(\\\\\\\"=\\\\\\\");\\\\n            headers[key] = value;\\\\n        }\\\\n        return [picUrl, headers];\\\\n    },\\\\n    range(start, end) {\\\\n        return Array(end - start).fill(0).map((el, i) => start + i);\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#j.Config\\\",\\\"path\\\":\\\"Config.json\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\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: 16,\\\\n    def_isPaginate: \\\\\\\"1\\\\\\\", //1默认开启分页，0默认关闭\\\\n    viewPageSize: 200,\\\\n    def_Pic: \\\\\\\"hiker://images/home_pic4\\\\\\\",\\\\n    def_Lord_Type: \\\\\\\"comic\\\\\\\",\\\\n    def_View_Style: \\\\\\\"text_1\\\\\\\",\\\\n    def_DoVi_Style: \\\\\\\"text_2\\\\\\\",\\\\n    def_DoVi_Type: \\\\\\\"1\\\\\\\", //0全部, 1未完成，2已完成\\\\n}, localConfig);\\\\nconst PATHS = {\\\\n    novelPath: \\\\\\\"/小说/\\\\\\\",\\\\n    comicPath: \\\\\\\"/漫画/\\\\\\\",\\\\n    novelFullPath: \\\\\\\"/小说合并/\\\\\\\",\\\\n    externalImportPath: \\\\\\\"/外导小说/\\\\\\\"\\\\n}\\\\n\\\\n\\\\nObject.keys(PATHS).forEach(key => Config[key] = Config.homePath + PATHS[key]);\\\\n$.exports = Config;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.主页面\\\",\\\"path\\\":\\\"Main.view\\\",\\\"rule\\\":\\\"js:\\\\nfunction main() {\\\\n    var layout = [];\\\\n    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n    const Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n    let type = getMyVar(\\\\\\\".type\\\\\\\", 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\\\\\\\" ? \\\\\\\"◉TXT\\\\\\\" : \\\\\\\"○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) => {\\\\n                    if (\\\\\\\"跳转小程序\\\\\\\" === input) {\\\\n                        return \\\\\\\"hiker://home@\\\\\\\" + it.name;\\\\n                    } else {\\\\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                    }\\\\n                }, it)\\\\n            });\\\\n        } else {\\\\n            layout.push({\\\\n                title: it.name,\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(i => {\\\\n                    putMyVar(\\\\\\\".tgnum\\\\\\\", i);\\\\n                    refreshPage();\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }, i),\\\\n            });\\\\n        }\\\\n    }\\\\n    let path = tag[tgnum].path;\\\\n    let mhlist = File.getFilePath(path, \\\\\\\"dir\\\\\\\");\\\\n\\\\n    if (mhlist.length === 0) {\\\\n        layout.push({\\\\n            title: \\\\\\\"““””\\\\\\\" + \\\\\\\"啥都没有耶\\\\\\\".big(),\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        })\\\\n        return setResult(layout);\\\\n    }\\\\n    let pageUrl = type === \\\\\\\"novel\\\\\\\" ? \\\\\\\"hiker://page/NovelBrowser.view\\\\\\\" : \\\\\\\"hiker://page/ComicBrowser.view\\\\\\\";\\\\n    for (let item of mhlist) {\\\\n        let pic = fileExist(\\\\\\\"file://\\\\\\\" + item.path + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\".jpg\\\\\\\") ? item.path + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\".jpg\\\\\\\" : Config.def_Pic;\\\\n        layout.push({\\\\n            title: item.name,\\\\n            pic_url: pic,\\\\n            url: pageUrl + \\\\\\\"?rule=\\\\\\\" + MY_RULE.title,\\\\n            extra: item\\\\n        });\\\\n    }\\\\n    setResult(layout);\\\\n}\\\\n\\\\nmain();\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.漫画章节列表\\\",\\\"path\\\":\\\"ComicBrowser.view\\\",\\\"rule\\\":\\\"js:\\\\nif (getParam(\\\\\\\"hasParams\\\\\\\") === \\\\\\\"true\\\\\\\") {\\\\n    MY_PARAMS = {\\\\n        path: decodeURIComponent(getParam(\\\\\\\"path\\\\\\\")),\\\\n        name: decodeURIComponent(getParam(\\\\\\\"name\\\\\\\"))\\\\n    }\\\\n}\\\\nlet path = MY_PARAMS.path;\\\\nsetPageTitle(\\\\\\\"CV|\\\\\\\" + MY_PARAMS.name)\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nvar layout = [];\\\\nlet mode = getMyVar(\\\\\\\".mode\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet isReverse = getMyVar(\\\\\\\".isReverse\\\\\\\", \\\\\\\"0\\\\\\\");\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\".mode\\\\\\\");\\\\n    clearMyVar(\\\\\\\".isReverse\\\\\\\");\\\\n}));\\\\nconst comicStatus=new Map([[\\\\\\\"A\\\\\\\",\\\\\\\"\\\\\\\"],[\\\\\\\"B\\\\\\\",\\\\\\\"‘‘[未完成]’’\\\\\\\"]]);\\\\nfunction getTitle(title) {\\\\n    let titles = Tool.split(title, \\\\\\\"$\\\\\\\", 2);\\\\n    return comicStatus.get(titles[1])+titles[2] || title;\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"删除整本\\\\\\\",\\\\n    url: $(\\\\\\\"确认删除整本漫画？\\\\\\\").confirm((path) => {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        if (File.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 = [];\\\\nlet lazy = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n    let filelist = File.getFilePath(input);\\\\n    let piclist = filelist.map((item, i) => \\\\\\\"file://\\\\\\\" + input + \\\\\\\"/\\\\\\\" + (i + 1) + \\\\\\\".jpg\\\\\\\");\\\\n    return \\\\\\\"pics://\\\\\\\" + piclist.join(\\\\\\\"&&\\\\\\\");\\\\n})\\\\nif (mode === \\\\\\\"0\\\\\\\") {\\\\n    for (let item of mhlist) {\\\\n        array.push({\\\\n            title: getTitle(item.name),\\\\n            url: item.path+lazy,\\\\n            col_type: Config.def_View_Style\\\\n        });\\\\n    }\\\\n} else {\\\\n    for (let item of mhlist) {\\\\n        let name = getTitle(item.name);\\\\n        array.push({\\\\n            title: name,\\\\n            url: $(\\\\\\\"确认删除[\\\\\\\" + name + \\\\\\\"]？\\\\\\\").confirm((path) => {\\\\n                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                if (File.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 termsArr = searchTerms.split(\\\\\\\"\\\\\\\").map(t => t.replace(/\\\\\\\\*|\\\\\\\\.|\\\\\\\\?|\\\\\\\\+|\\\\\\\\$|\\\\\\\\^|\\\\\\\\[|\\\\\\\\]|\\\\\\\\(|\\\\\\\\)|\\\\\\\\{|\\\\\\\\}|\\\\\\\\||\\\\\\\\/|\\\\\\\\\\\\\\\\/g, k => \\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\" + k));\\\\nlet reg = new RegExp(termsArr.join(\\\\\\\".*\\\\\\\"),\\\\\\\"i\\\\\\\");\\\\nlet pageUrl=getParam(\\\\\\\"type\\\\\\\")===\\\\\\\"novel\\\\\\\"?\\\\\\\"hiker://page/NovelBrowser.view\\\\\\\":\\\\\\\"hiker://page/ComicBrowser.view\\\\\\\";\\\\nfor (let sonDir of comicRuleDirs) {\\\\n    let comicList = File.getFilePath(sonDir.path, \\\\\\\"dir\\\\\\\");\\\\n    for (let comic of comicList) {\\\\n        if (reg.test(comic.name)) {\\\\n            searchResult.push({\\\\n                title: comic.name,\\\\n                pic_url: comic.path + \\\\\\\"/\\\\\\\" + comic.name + \\\\\\\".jpg\\\\\\\",\\\\n                url: pageUrl+\\\\\\\"?rule=\\\\\\\" + MY_RULE._title,\\\\n                desc: sonDir.name,\\\\n                extra: comic\\\\n            });\\\\n        }\\\\n    }\\\\n\\\\n}\\\\nsetResult(searchResult);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.设置\\\",\\\"path\\\":\\\"Setting.view\\\",\\\"rule\\\":\\\"js:\\\\nsetPageTitle(MY_RULE.title + \\\\\\\"|设置\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n\\\\nlet layout = [];\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>基础设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"目录路径\\\\\\\",\\\\n    url: \\\\\\\"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: \\\\\\\"hiker://page/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\\\\\",\\\\n    extra: {\\\\n        lver: MY_PARAMS.version || \\\\\\\"获取版本失败，自行查看\\\\\\\",\\\\n        id: \\\\\\\"3559\\\\\\\"\\\\n    },\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"关于如何调用\\\\\\\",\\\\n    url: \\\\\\\"https://qun.qq.com/qqweb/qunpro/share?_wv=3&_wwv=128&inviteCode=1HFyBJ&from=246610&biz=ka\\\\\\\",\\\\n    desc: \\\\\\\"详细点击加入频道，频道里@LoyDgIk\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"恢复默认设置\\\\\\\",\\\\n    url: $(\\\\\\\"确认恢复默认设置？\\\\\\\").confirm(() => {\\\\n        deleteFile(\\\\\\\"config.json\\\\\\\");\\\\n        refreshPage(false);\\\\n        return \\\\\\\"toast://恢复完成\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"清理缓存\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRecordHistory##noHistory#?settingType=cache\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\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});\\\\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(/^\\\\\\\\s+|\\\\\\\\s+$/gm, \\\\\\\"\\\\\\\").replace(/&nbsp;/g,\\\\\\\"\\\\\\\").split(/\\\\\\\\n+/).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\\\\\\\") || \\\\\\\"{}\\\\\\\"));\\\\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}\\\\ncontent = \\\\\\\"　　\\\\\\\" + content.replace(/^\\\\\\\\s+|\\\\\\\\s+$/gm, \\\\\\\"\\\\\\\").split(/\\\\\\\\n+/).join(\\\\\\\"<br>　　\\\\\\\");\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    title: (\\\\\\\"<strong>\\\\\\\" + MY_PARAMS.title + \\\\\\\"</strong>\\\\\\\").big(),\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: content,\\\\n    col_type: 'rich_text',\\\\n    extra: {\\\\n        textSize: 18,\\\\n        click: true\\\\n    }\\\\n});\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.合并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.外导TXT\\\",\\\"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, undefined, \\\\\\\".txt\\\\\\\");\\\\n    setPageTitle(\\\\\\\"外导TXT\\\\\\\");\\\\n    //let layout = [];\\\\n    layout.push({\\\\n        title: \\\\\\\"导入TXT\\\\\\\",\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n        url: $([\\\\\\\"系统选择器\\\\\\\", \\\\\\\"海阔选择器\\\\\\\"], 1, \\\\\\\"选择器类型\\\\\\\").select(() => {\\\\n            if (input === \\\\\\\"系统选择器\\\\\\\") {\\\\n                return \\\\\\\"fileSelect://\\\\\\\" + $.toString(() => {\\\\n                    if (!/(\\\\\\\\.txt)$/i.test(input)) {\\\\n                        toast(\\\\\\\"选择了错误的文件类型\\\\\\\");\\\\n                        return;\\\\n                    }\\\\n                    const Config = $.require(\\\\\\\"hiker://page/Config.json\\\\\\\");\\\\n                    let novelName = input.match(/\\\\\\\\/([^\\\\\\\\/]*?)(\\\\\\\\.txt)$/i)[1].replace(\\\\\\\"_fileSelect_\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                    let topath = Config.externalImportPath + novelName + \\\\\\\".txt\\\\\\\";\\\\n                    let path = input.replace(\\\\\\\"file://\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                    if (fileExist(\\\\\\\"file://\\\\\\\" + topath)) {\\\\n                        confirm({\\\\n                            title: \\\\\\\"导入提示\\\\\\\",\\\\n                            content: \\\\\\\"已存在[\\\\\\\" + novelName + \\\\\\\"]是否覆盖?\\\\\\\",\\\\n                            confirm: $.toString((path, topath) => {\\\\n                                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                                File.copyFile(path, topath, true);\\\\n                                if (fileExist(\\\\\\\"file://\\\\\\\" + topath + \\\\\\\".json\\\\\\\")) {\\\\n                                    File.deleteFiles(topath + \\\\\\\".json\\\\\\\");\\\\n                                }\\\\n                                refreshPage(false);\\\\n                                return \\\\\\\"toast://导入成功\\\\\\\";\\\\n                            }, path, topath)\\\\n                        });\\\\n                        return;\\\\n                    } else {\\\\n                        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                        File.copyFile(path, topath);\\\\n                        if (fileExist(\\\\\\\"file://\\\\\\\" + topath + \\\\\\\".json\\\\\\\")) {\\\\n                            File.deleteFiles(topath + \\\\\\\".json\\\\\\\");\\\\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 novelName = PATH.match(/\\\\\\\\/([^\\\\\\\\/]*?)(\\\\\\\\.txt)$/i)[1];\\\\n                        let topath = Config.externalImportPath + novelName + \\\\\\\".txt\\\\\\\";\\\\n                        let path = PATH;\\\\n                        if (fileExist(\\\\\\\"file://\\\\\\\" + topath)) {\\\\n                            return $(\\\\\\\"已存在[\\\\\\\" + novelName + \\\\\\\"]是否覆盖?\\\\\\\").confirm((path, topath) => {\\\\n                                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                                File.copyFile(path, topath, true);\\\\n                                if (fileExist(\\\\\\\"file://\\\\\\\" + topath + \\\\\\\".json\\\\\\\")) {\\\\n                                    File.deleteFiles(topath + \\\\\\\".json\\\\\\\");\\\\n                                }\\\\n                                back();\\\\n                                return \\\\\\\"toast://导入成功\\\\\\\";\\\\n                            }, path, topath);\\\\n                        } else {\\\\n                            const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                            File.copyFile(path, topath);\\\\n                            if (fileExist(\\\\\\\"file://\\\\\\\" + topath + \\\\\\\".json\\\\\\\")) {\\\\n                                File.deleteFiles(topath + \\\\\\\".json\\\\\\\");\\\\n                            }\\\\n                            back();\\\\n                            return \\\\\\\"toast://导入成功\\\\\\\";\\\\n                        }\\\\n                    }),\\\\n                    requireUrl: requireUrl,\\\\n                    fileType: \\\\\\\".txt\\\\\\\",\\\\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_2\\\\\\\",\\\\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        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n\\\\n    function operation(path, name) {\\\\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                        return \\\\\\\"toast://删除成功\\\\\\\";\\\\n                    } else {\\\\n                        return \\\\\\\"toast://删除失败\\\\\\\";\\\\n                    }\\\\n                }, path);\\\\n                break;\\\\n            case \\\\\\\"阅读\\\\\\\":\\\\n                return \\\\\\\"hiker://page/txtParser.view\\\\\\\";\\\\n                break;\\\\n            case \\\\\\\"打开方式\\\\\\\":\\\\n                return \\\\\\\"openFile://file://\\\\\\\" + path;\\\\n                break;\\\\n        }\\\\n    }\\\\n\\\\n    for (let novel of files) {\\\\n        layout.push({\\\\n            title: novel.name,\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(operation, novel.path, novel.name),\\\\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            }\\\\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}\\\\n\\\\n$.exports = txtView;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.TXT解析器\\\",\\\"path\\\":\\\"txtParser.view\\\",\\\"rule\\\":\\\"js:\\\\n(function() {\\\\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 = MY_PARAMS.isCache;\\\\n    if (!path.startsWith(\\\\\\\"file://\\\\\\\")) {\\\\n        path = \\\\\\\"file://\\\\\\\" + path;\\\\n    }\\\\n    let layout = [];\\\\n    let chapterNames = [];\\\\n    let intervals = [];\\\\n    let hasPreface = false;\\\\n    if (fileExist(path + \\\\\\\".json\\\\\\\") && isCache) {\\\\n        try {\\\\n\\\\n            let c = JSON.parse(request(path + \\\\\\\".json\\\\\\\"));\\\\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(path + \\\\\\\".json\\\\\\\", 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+/).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}\\\"}]\",\"proxy\":\"\"}","title":"选择器|[综]用绳命推销的男人 作者：醉饮长歌"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!