API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：帮助

xiaomianao666
Jun 9th, 2024
128
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 478.75 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥帮助@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"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    if (expand) {\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\n    }\\n    return pathList;\\n}\\n\\nfunction getFiles(path, type, expand) {\\n    let types = {\\n        \\\"file\\\": \\\"isFile\\\",\\n        \\\"dir\\\": \\\"isDirectory\\\"\\n    };\\n    let fileType = types[type];\\n    let file = new File(path);\\n    let array = file.listFiles() || [];\\n    let fileList = [];\\n    for (let i = 0; i < array.length; i++) {\\n        let file = array[i];\\n        if ((!fileType || file[fileType]()) && (!expand || file.getName().endsWith(expand))) {\\n            fileList.push(file);\\n        }\\n    }\\n    return fileList;\\n}\\n\\nfunction renameFile(fromPath, name) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(fromFile.getParent() + \\\"/\\\" + name);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!toFile.delete()) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction moveFiles(fromPath, toPath) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(toPath);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!deleteFiles(toPath)) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction fileWrite(path, content) {\\n    writeFile(\\\"file://\\\" + path, content)\\n}\\n\\nfunction fileWriteAppend(path, content) {\\n    let file = new File(path);\\n    let paths = file.toPath();\\n    if (file.exists()) {\\n        Files.write(paths, new javaString(content).getBytes(), StandardOpenOption.APPEND);\\n    } else {\\n        writeFile(\\\"file://\\\" + path, content);\\n    }\\n}\\n\\nfunction getTotalSizeOfFilesInDir(file) {\\n    if (file.isFile()) {\\n        return file.length();\\n    }\\n    let children = file.listFiles();\\n    let total = 0;\\n    if (children != null) {\\n        for (let child of children) {\\n            total += getTotalSizeOfFilesInDir(child);\\n        }\\n    }\\n    return total;\\n}\\n\\nfunction getFileSize(filePath) {\\n    //Byte\\n    let size = getTotalSizeOfFilesInDir(new File(filePath));\\n    if (size < 0) {\\n        return null;\\n    }\\n    let unitForm = [\\\"Byte\\\", \\\"KB\\\", \\\"MB\\\", \\\"GB\\\", \\\"TB\\\"];\\n    for (let i = 0, len = unitForm.length; i < len; i++) {\\n        if (size > 1024) {\\n            size /= 1024;\\n            continue;\\n        } else {\\n            return size.toFixed(2).replace(/(\\\\.00)$/, \\\"\\\") + unitForm[i];\\n        }\\n    }\\n    return \\\"ERROR:数值过大\\\";\\n}\\n//完整合并\\n/*\\nfunction fileCombine(filesInput, fileOut, extension, intercept) {\\n    with(javaScope) {\\n        const TMP_BUFFER_SIZE = 0x30000;\\n        const BUFFER_SIZE = 0x300000;\\n        //合并临时文件\\n        let inputFile = new File(filesInput);\\n        let tmpFile = new File(fileOut + \\\".tmp\\\");\\n        let tos = new BufferedOutputStream(new FileOutputStream(tmpFile));\\n        let inputFiles = inputFile.listFiles();\\n        let tbys = Array.newInstance(Byte.TYPE, TMP_BUFFER_SIZE);\\n        for (let file of inputFiles) {\\n            if (file.getName().endsWith(extension)) {\\n                let is = new FileInputStream(file);\\n                let len = 0;\\n                while ((len = is.read(tbys)) != -1) {\\n                    tos.write(tbys, 0, len);\\n                }\\n                is.close();\\n            }\\n        }\\n        tos.close();\\n        //规则替换规则;\\n        let outFile = new File(fileOut);\\n        if (typeof intercept === \\\"function\\\") {\\n            let tis = new FileInputStream(tmpFile);\\n            let os = new BufferedOutputStream(new FileOutputStream(outFile));\\n            let len = 0;\\n            let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\n            while ((len = tis.read(bys)) != -1) {\\n                let nbys = intercept(new String(bys,0,len));\\n                os.write(nbys, 0, nbys.length);\\n            }\\n            tmpFile.delete();\\n            tis.close();\\n            os.close();\\n        } else {\\n            if (outFile.exists()) {\\n                outFile.delete();\\n            }\\n            tmpFile.renameTo(outFile);\\n        }\\n    }\\n}*/\\n//残\\nfunction fileRule(filesInput, fileOut, intercept) {\\n    with(javaScope) {\\n        const BUFFER_SIZE = 0x300000;\\n        let tmpFile = new File(filesInput);\\n        if (!(tmpFile.exists() && tmpFile.isFile())) {\\n            return false;\\n        }\\n        let outFile = new File(fileOut);\\n\\n        let tis = new FileInputStream(tmpFile);\\n        let os = new BufferedOutputStream(new FileOutputStream(outFile));\\n        let len = 0;\\n        let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\n        while ((len = tis.read(bys)) != -1) {\\n            let nbys = intercept(new String(bys, 0, len));\\n            os.write(nbys, 0, nbys.length);\\n        }\\n        tmpFile.delete();\\n        tis.close();\\n        os.close();\\n        return true;\\n    }\\n}\\n\\nfunction readFile(path) {\\n    try {\\n        let paths = Paths.get(path);\\n        if (!Files.exists(paths)) return \\\"\\\";\\n        return String(new javaString(Files.readAllBytes(paths)));\\n    } catch {\\n        return \\\"\\\";\\n    }\\n}\\n$.exports = {\\n    getFileTime: (path) => getFileTime(path),\\n    getFilePath: (path, type, expand) => getFilePath(path, type, expand),\\n    deleteFiles: (path) => deleteFiles(path),\\n    renameFile: (path, name) => renameFile(path, name),\\n    moveFiles: (fromPath, toPath) => moveFiles(fromPath, toPath),\\n    fileWrite: (path, content) => fileWrite(path, content),\\n    fileWriteAppend: (path, content) => fileWriteAppend(path, content),\\n    getName: (path) => getName(path),\\n    getFileSize: (filePath) => getFileSize(filePath),\\n    fileRule: (filesInput, fileOut, intercept) => fileRule(filesInput, fileOut, intercept),\\n    copyFile: (source, target, isCover) => copyFile(source, target, isCover),\\n    readFile: (path) => readFile(path),\\n    getFiles: (path, type, expand) => getFiles(path, type, expand),\\n    getTotalSizeOfFilesInDir:(file)=>getTotalSizeOfFilesInDir(file)\\n}\"},{\"col_type\":\"text_2\",\"name\":\"#v.下载列表-普通下载\",\"path\":\"download.view\",\"rule\":\"js:\\nconst viewConfig = Object.assign({\\n    chapterList: [],\\n    info: {},\\n    defaultView: \\\"0\\\"\\n}, MY_PARAMS);\\nviewConfig.info = Object.assign({\\n    ruleName: \\\"\\\",\\n    bookName: \\\"\\\",\\n    bookTopPic: \\\"\\\",\\n    parseCode: \\\"\\\",\\n    decode: undefined,\\n    type: \\\"comic\\\",\\n    comicScheme: \\\"1\\\",\\n    bookId:\\\"\\\",\\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.js\\\");\\n\\nviewConfig.info.bookName = Tool.textShield(viewConfig.info.bookName);\\nviewConfig.info.ruleName = Tool.textShield(viewConfig.info.ruleName);\\n\\nconst MY_ID = info.ruleName + \\\"//\\\" + info.bookName+\\\"//\\\"+info.bookId;\\nlet boid=info.bookId?\\\"$\\\"+info.bookId:\\\"\\\";\\nconst cpath=\\\"/\\\" + info.ruleName + \\\"/\\\" + info.bookName+boid;\\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    if (chapterList.startsWith(\\\"hiker://files/\\\")) {\\n        chapterList = getPath(chapterList).slice(7);\\n        backupChapterList = chapterList;\\n    }\\n    chapterList = JSON.parse(request(\\\"file://\\\" + chapterList) || \\\"[]\\\");\\n}\\nlet chapterAll = chapterList;\\nchapterList = chapterList.map((item, CID) => {\\n    item.CID = CID;\\n    item.title = Tool.textShield(item.title);\\n    return item;\\n});\\nlet pageNum = Number(getMyVar(MY_ID + \\\":pageNum\\\", \\\"1\\\"));\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\nchapterList = chapterChunk[pageNum] || [];\\nconst def_DoVi_Style = chapterAll.length === 1 ? \\\"text_center_1\\\" : Config.def_DoVi_Style;\\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 + cpath + \\\"/\\\" + 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\\\"] +cpath, \\\"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 + cpath + \\\"/\\\" + 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\\\"] + cpath, \\\"file\\\", \\\".txt\\\").forEach((file) => {\\n        let att = Tool.split(file.name, \\\"$\\\", 2);\\n        if (att.length === 3 && att[1] === (\\\"A\\\")) {\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\".\\\")));\\n        }\\n    });\\n}\\n\\nfunction clickDownload(item, info, MY_ID, i) {\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = loadingTeam.indexOf(i);\\n    if (ElementIndex > -1) return \\\"toast://正在下载\\\";\\n\\n    loadingTeam.push(i);\\n    putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    updateItem({\\n        title: \\\"‘‘\\\" + item.title + \\\"’’\\\",\\n        extra: {\\n            id: MY_ID + \\\"#\\\" + i\\n        }\\n    });\\n    let result = \\\"toast://下载失败\\\";\\n    try {\\n        toast(\\\"开始下载:\\\" + item.title);\\n        let download = $.require(\\\"hiker://page/Download.exe.js\\\");\\n        result = download(item, info, i, MY_ID);\\n        updateItem({\\n            title: \\\"““\\\" + item.title + \\\"””\\\",\\n            url: \\\"toast://已下载\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n    } catch (e) {\\n        updateItem({\\n            title: item.title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        log(e.toString());\\n    } finally {\\n        loadingTeam.splice(ElementIndex, 1);\\n        putMyVar(MY_ID + \\\":loadingTeam\\\", JSON.stringify(loadingTeam));\\n    }\\n    return result;\\n}\\n\\nfunction singleView() {\\n    layout.push({\\n        title: \\\"反转列表\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((isReverse, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, isReverse, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    layout.push({\\n        title: \\\"批量下载\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            if (loadingTeam.length > 0) return \\\"toast://还有任务没有完成\\\";\\n            if (getAppVersion() < 2594) return \\\"toast://未开放\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"1\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n\\n        }, MY_ID),\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\",\\n        col_type: \\\"icon_2\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\":loadingTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n        if (is_download && tagFilter !== \\\"1\\\") {\\n            chapterTeam.push(comFun(item.CID, item));\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: loadingTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n}\\n\\nfunction clickChoose(title, MY_ID, i) {\\n    let isStart = getMyVar(MY_ID + \\\":isStart\\\");\\n    if (isStart === \\\"1\\\") return \\\"toast://正在下载...\\\";\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let ElementIndex = batchTeam.indexOf(i);\\n    if (ElementIndex > -1) {\\n        updateItem({\\n            title: title,\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.splice(ElementIndex, 1);\\n    } else {\\n        updateItem({\\n            title: \\\"‘‘\\\" + title + \\\"’’\\\",\\n            extra: {\\n                id: MY_ID + \\\"#\\\" + i\\n            }\\n        });\\n        batchTeam.push(i);\\n    }\\n    putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n    return \\\"hiker://empty\\\";\\n}\\n\\nfunction batchView() {\\n    layout.push({\\n        title: \\\"单选下载\\\",\\n        pic_url: \\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在批量下载\\\";\\n            putMyVar(MY_ID + \\\":viewMode\\\", \\\"0\\\");\\n            clearMyVar(MY_ID + \\\":batchTeam\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\n    let end = start + chapterList.length;\\n    layout.push({\\n        title: \\\"选择全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在下载哦~\\\";\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = Tool.range(start, end);\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\":completed\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"取消全部\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((start, end, MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\") === \\\"1\\\") return \\\"toast://正在下载哦~\\\";\\n            const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n            let chooseTeam = new Set(Tool.range(start, end));\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, start, end, MY_ID),\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    layout.push({\\n        title: \\\"确认选中\\\",\\n        pic_url: \\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            if (getMyVar(MY_ID + \\\":isStart\\\", \\\"-1\\\") !== \\\"-1\\\") {\\n                return \\\"toast://正在下载哦~\\\";\\n            }\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            return batchTeam.length === 0 ? \\\"toast://你还什么都没有选\\\" : \\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\";\\n        }, MY_ID),\\n        extra: {\\n            newWindow: true,\\n            windowId: MY_ID + \\\"//批量下载\\\",\\n            MY_ID: MY_ID,\\n            chapterList: backupChapterList,\\n            info: info\\n        },\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    setType();\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let completed = [];\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\n        let is_download = record.includes(item.title);\\n\\n        if (is_download) {\\n            completed.push(item.CID);\\n            if (tagFilter !== \\\"1\\\") {\\n                chapterTeam.push(comFun(item.CID, item));\\n            }\\n        } else if (!is_download && tagFilter !== \\\"2\\\") {\\n            chapterTeam.push({\\n                title: batchTeam.includes(item.CID) ? \\\"‘‘\\\" + item.title + \\\"’’\\\" : item.title,\\n                url: $(\\\"#noLoading#\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\n                extra: {\\n                    id: MY_ID + \\\"#\\\" + item.CID\\n                },\\n                col_type: def_DoVi_Style\\n            });\\n        }\\n    }\\n    putMyVar(MY_ID + \\\":completed\\\", JSON.stringify(completed));\\n}\\nswitch (viewMode) {\\n    case \\\"0\\\":\\n        singleView();\\n        break;\\n    case \\\"1\\\":\\n        batchView();\\n        break;\\n}\\nif (isReverse === \\\"1\\\") {\\n    chapterTeam.reverse();\\n}\\nlayout.push.apply(layout, chapterTeam);\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.批量下载器\",\"path\":\"Batch.view\",\"rule\":\"js:\\nlet {\\n    chapterList,\\n    info,\\n    MY_ID\\n} = MY_PARAMS;\\nsetPageTitle(\\\"下载器|\\\"+info.bookName);\\naddListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n    clearMyVar(MY_ID + \\\":isStart\\\");\\n    clearMyVar(MY_ID + \\\":status\\\");\\n    clearMyVar(MY_ID + \\\":batchTeam\\\");\\n    refreshPage();\\n}, MY_ID));\\n\\nlet isStart = getMyVar(MY_ID + \\\":isStart\\\", \\\"0\\\");\\nlet status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\nlet layout = [];\\n\\nlet batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\nif(typeof chapterList === \\\"string\\\"){\\n    chapterList = JSON.parse(request(\\\"file://\\\"+chapterList)||\\\"[]\\\");\\n}\\nlet chapterTeam = batchTeam.map(v => {\\n    let chapterItem = chapterList[v];\\n    chapterItem.CID = v;\\n    return chapterItem;\\n});\\nif (isStart === \\\"0\\\") {\\n    layout.push({\\n        title: \\\"开始下载[\\\" + chapterTeam.length + \\\"]\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((chapterTeam, info, MY_ID) => {\\n            putMyVar(MY_ID + \\\":isStart\\\", \\\"1\\\");\\n            refreshPage(false);\\n            let download = $.require(\\\"hiker://page/BatchStatistics.js\\\");\\n            if(info.type===\\\"comic\\\"&&info.comicScheme===\\\"1\\\"){\\n                download=download.b;\\n            }else{\\n                download=download.a;\\n            }\\n            return download(chapterTeam, info, MY_ID) || \\\"toast://下载错误\\\";\\n        }, chapterTeam, info, MY_ID),\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"||开始下载\\\"\\n        }\\n    });\\n    layout.push({\\n        title: \\\"任务列表：\\\",\\n        col_type: \\\"rich_text\\\",\\n    });\\n    for (let item of chapterTeam) {\\n        layout.push({\\n            title: item.title,\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_2\\\"\\n        });\\n    }\\n\\n} else {\\n    layout.push({\\n        title: \\\"下载进度:0/\\\"+chapterTeam.length,\\n        desc: \\\"““””▇▇▇▇▇▇▇▇▇▇\\\".fontcolor(\\\"#e5e1e4\\\")+\\\" 0%\\\",\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"||下载进度\\\",\\n            lineVisible: false\\n        }\\n    });\\n    layout.push({\\n        title: \\\"后台下载\\\",\\n        url: \\\"func://background\\\",\\n        col_type: \\\"text_2\\\"\\n    });\\n\\n    layout.push({\\n        title: [\\\"[取消下载]\\\", \\\"[正在停止...]\\\", \\\"[返回]\\\", \\\"[处理失败]\\\", \\\"[重新开始]\\\"][status],\\n        url: $(\\\"#noLoading#\\\").lazyRule((MY_ID) => {\\n            let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n            if (status === \\\"0\\\") {\\n                putMyVar(MY_ID + \\\":status\\\", \\\"1\\\");\\n                updateItem({\\n                    title: \\\"[正在停止...]\\\",\\n                    extra: {\\n                        id: MY_ID + \\\"||下载控制\\\"\\n                    }\\n                });\\n                return \\\"toast://正在取消下载任务\\\";\\n            } else if (status === \\\"1\\\") {\\n                return \\\"toast://正在暂停...\\\";\\n            } else if (status === \\\"2\\\") {\\n                back();\\n                return \\\"toast://已退出下载器\\\";\\n            } else if ([\\\"3\\\", \\\"4\\\"].includes(status)) {\\n                clearMyVar(MY_ID + \\\":isStart\\\");\\n                clearMyVar(MY_ID + \\\":status\\\");\\n                clearMyVar(MY_ID + \\\":log\\\");\\n                refreshPage();\\n                return \\\"toast://重新点击下载\\\"\\n            }\\n        }, MY_ID),\\n        col_type: \\\"text_2\\\",\\n        extra: {\\n            id: MY_ID + \\\"||下载控制\\\"\\n        }\\n    });\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    layout.push({\\n        title: \\\"<strong>下载日志</strong>\\\".big(),\\n        col_type: \\\"rich_text\\\",\\n        \\n    });\\n    layout.push({\\n        col_type: \\\"line\\\",\\n        extra: {\\n            id: MY_ID + \\\"||日志\\\"\\n        }\\n    });\\n    layout.push({\\n        title:\\\"““””$>\\\"+\\\"开始下载......\\\".fontcolor(\\\"#00ff00\\\"),\\n        url:\\\"hiker://empty\\\",\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            id: MY_ID + \\\"#log#0\\\",\\n            lineVisible:false\\n        }\\n    });\\n}\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.批量下载统计\",\"path\":\"BatchStatistics.js\",\"rule\":\"const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.js\\\");\\n\\n$.exports.a = function(chapterTeam, info, MY_ID) {\\n    if (chapterTeam.length === 0) {\\n        return \\\"toast://空的下载队列\\\";\\n    }\\n\\n    var count = 0;\\n    var taskCount = chapterTeam.length;\\n    var successCID = [];\\n    var failName = [];\\n    var logCount = 1;\\n    var taskTeam = chapterTeam.map(chapterItem => ({\\n        func: task,\\n        id: chapterItem.title,\\n        param: {\\n            chapterItem: chapterItem,\\n            info: info,\\n            MY_ID: MY_ID\\n        }\\n    }));\\n    let logNum = Config.logNum;\\n\\n\\n    function putLog(text) {\\n        log(text);\\n        if (logCount >= logNum) {\\n            deleteItem(MY_ID + \\\"#log#\\\" + (logCount - 10));\\n        }\\n        addItemAfter(MY_ID + \\\"||日志\\\", {\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"$>\\\" + text,\\n            col_type: \\\"text_1\\\",\\n            extra: {\\n                lineVisible: false,\\n                id: MY_ID + \\\"#log#\\\" + logCount\\n            }\\n        });\\n        logCount++;\\n    }\\n\\n    function task(taskParam) {\\n        let result = $.require(\\\"hiker://page/Batch.exe.js\\\")(taskParam);\\n        return result;\\n    }\\n\\n    function listener(perch, id, error, CID) {\\n        count++;\\n        let isSuccess = false;\\n        if (error != null) {\\n            failName.push(id);\\n            putLog(\\\"[listener]下载失败：\\\" + id + \\\"<ERROR@ \\\" + error + \\\">\\\");\\n        } else if (CID >= 0) {\\n            successCID.push(CID);\\n            let ratio = (count / taskCount).toFixed(4);\\n            let stripCount = Math.ceil(ratio * 10);\\n            isSuccess = true;\\n            updateItem({\\n                title: \\\"下载进度：\\\" + successCID.length + \\\"/\\\" + taskCount,\\n                desc: \\\"““””\\\" + \\\"▇\\\".repeat(stripCount).fontcolor(\\\"#ffac2d\\\") + \\\"▇\\\".repeat(10 - stripCount).fontcolor(\\\"#e5e1e4\\\") + \\\" \\\" + String((ratio * 100)).slice(0, 5) + \\\"%\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载进度\\\"\\n                }\\n            });\\n            putLog(\\\"[listener]已完成下载：\\\" + id);\\n        } else if (CID === -1) {\\n            failName.push(id);\\n            putLog(\\\"[listener]已停止：\\\" + id);\\n            count = taskCount;\\n        }\\n\\n        if (taskCount !== count) return;\\n        if (successCID.length === taskCount) {\\n            updateItem({\\n                desc: \\\"““””\\\" + \\\"▇\\\".repeat(10).fontcolor(\\\"#00ff00\\\") + \\\" 100%\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载进度\\\"\\n                }\\n            });\\n        }\\n        let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n        let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n        let failTeam = batchTeam.filter(v => !successCID.includes(v));\\n        putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(failTeam));\\n        if (failTeam.length > 0 && status !== \\\"1\\\") {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"3\\\");\\n            putLog(\\\"下载失败:[\\\" + failName.join(\\\"]，[\\\") + \\\"]。\\\");\\n            updateItem({\\n                title: \\\"[处理失败]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        } else if (failTeam.length > 0 && status === \\\"1\\\") {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"4\\\");\\n            putLog(\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\");\\n            updateItem({\\n                title: \\\"[重新开始]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n            return \\\"break\\\";\\n        } else {\\n            putMyVar(MY_ID + \\\":status\\\", \\\"2\\\");\\n            putLog(\\\"下载任务[\\\" + info.bookName + \\\"]已全部成功完成\\\");\\n            updateItem({\\n                title: \\\"[返回]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n        }\\n        toast(\\\"下载任务[\\\" + info.bookName + \\\"]已完成\\\");\\n    }\\n    let taskTeamChunk = [];\\n    if (Config.threadNum > 0) {\\n        taskTeamChunk = Tool.chunk(taskTeam, Config.threadNum);\\n    } else {\\n        taskTeamChunk = [taskTeam];\\n    }\\n    for (let taskList of taskTeamChunk) {\\n        be(taskList, {\\n            func: listener\\n        });\\n        let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n        if (status === \\\"1\\\") {\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n            //let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n            let failTeam = batchTeam.filter(v => !successCID.includes(v));\\n            putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(failTeam));\\n            putMyVar(MY_ID + \\\":status\\\", \\\"4\\\");\\n            putLog(\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\");\\n            updateItem({\\n                title: \\\"[重新开始]\\\",\\n                extra: {\\n                    id: MY_ID + \\\"||下载控制\\\"\\n                }\\n            });\\n            return \\\"hiker://empty\\\";\\n        }\\n\\n    }\\n\\n    return \\\"hiker://empty\\\";\\n};\\n\\n$.exports.b = function comic(chapterTeam, info, MY_ID) {\\n    if (chapterTeam.length === 0) {\\n        return \\\"toast://空的下载队列\\\";\\n    }\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n\\n    let logNum = Config.logNum;\\n    let logCount = 0;\\n\\n    function putLog(text) {\\n        log(text);\\n        if (logCount >= logNum) {\\n            deleteItem(MY_ID + \\\"#log#\\\" + (logCount - 10));\\n        }\\n        addItemAfter(MY_ID + \\\"||日志\\\", {\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"$>\\\" + text,\\n            col_type: \\\"text_1\\\",\\n            extra: {\\n                lineVisible: false,\\n                id: MY_ID + \\\"#log#\\\" + logCount\\n            }\\n        });\\n        logCount++;\\n    }\\n\\n    function task(taskParam) {\\n        const Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n        for (let i = 0; i < 10; i++) {\\n            try {\\n                let pic = Tool.hikerPic(taskParam.url);\\n                Tool.picDownload(pic[0], taskParam.chapterPath + (taskParam.i + 1) + \\\".jpg\\\", pic[1], taskParam.decode);\\n                if (getMyVar(taskParam.MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n                    return -1;\\n                }\\n                errorNum = 0;\\n                break;\\n            } catch (e) {\\n                if (i === 9) {\\n                    throw e;\\n                }\\n            }\\n        }\\n        return taskParam.CID;\\n    }\\n    let count = 0;\\n    let totalCount = 0;\\n    let successCID = [];\\n\\n    function listener(param, id, error, result) {\\n        try {\\n            totalCount++;\\n\\n            if (error != null) {\\n                putLog(\\\"[listener]下载失败：\\\" + id + \\\"<ERROR@ \\\" + error + \\\">\\\");\\n            } else if (result === -1) {\\n                putLog(\\\"[listener]已停止：\\\" + id);\\n                totalCount = param.pivCount;\\n            } else {\\n                count++;\\n                let ratio = ((count / param.pivCount)).toFixed(4);\\n                let stripCount = Math.ceil(ratio * 10);\\n                if (param.pivCount === totalCount && totalCount === count) {\\n                    successCID.push(param.CID);\\n                }\\n                updateItem({\\n                    title: \\\"下载进度：\\\" + (successCID.length) + \\\"/\\\" + param.total,\\n                    desc: \\\"““””\\\" + \\\"▇\\\".repeat(stripCount).fontcolor(\\\"#ffac2d\\\") + \\\"▇\\\".repeat(10 - stripCount).fontcolor(\\\"#e5e1e4\\\") + \\\" \\\" + String((ratio * 100)).slice(0, 5) + \\\"%\\\",\\n                    extra: {\\n                        id: MY_ID + \\\"||下载进度\\\"\\n                    }\\n                });\\n                //putLog(\\\"[listener]已完成下载：\\\" + id);\\n            }\\n            if (totalCount !== param.pivCount) return;\\n            if (totalCount === count) {\\n                File.renameFile(param.chapterPath, param.CID + \\\"$A$\\\" + Tool.textShield(param.title));\\n            }\\n            totalCount = count = 0;\\n            return \\\"break\\\";\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n    let taskTeam = [];\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + Tool.textShield(info.bookName) + \\\"/\\\";\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + \\\".jpg\\\", bookTopPic[1], info.decode);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n\\n    for (let k = 0; k < chapterTeam.length; k++) {\\n        let item = chapterTeam[k];\\n        let order = k;\\n        let chapterPath = mainPath + item.CID + \\\"$B$\\\" + Tool.textShield(item.title) + \\\"/\\\";\\n        let picList = [];\\n        try {\\n            let getPicList = new Function(\\\"input\\\", \\\"url\\\", \\\"index\\\", \\\"title\\\", \\\"return\\\" + info.parseCode);\\n            picList = getPicList(item.url, item.url, k, item.title);\\n            if (typeof picList === \\\"string\\\") {\\n                picList = picList.replace(\\\"pics://\\\", \\\"\\\").split(\\\"&&\\\");\\n            }\\n        } catch (e) {\\n            putLog(\\\"<漫画图片解析错误> \\\" + e.message);\\n            continue;\\n        }\\n        if (picList.length === 0) {\\n            putLog(\\\"<漫画图片解析错误：图片链接返回为空>\\\");\\n            continue;\\n        }\\n        picList = picList.filter(p => p);\\n        var taskTeam = picList.map((url, i) => ({\\n            func: task,\\n            id: i,\\n            param: {\\n                url: url,\\n                i: i,\\n                chapterPath: chapterPath,\\n                MY_ID: MY_ID,\\n                decode: info.decode\\n            }\\n        }));\\n        be(taskTeam, {\\n            func: listener,\\n            param: {\\n                pivCount: picList.length,\\n                total: chapterTeam.length,\\n                order: order,\\n                CID: item.CID,\\n                title: item.title,\\n                chapterPath: chapterPath\\n            }\\n        });\\n        if (getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n            break;\\n        }\\n    }\\n\\n    let status = getMyVar(MY_ID + \\\":status\\\", \\\"0\\\");\\n    java.lang.Thread.sleep(40);\\n    //let batchTeam = JSON.parse(getMyVar(MY_ID + \\\":batchTeam\\\", \\\"[]\\\") || \\\"[]\\\");\\n    let failTeam = chapterTeam.filter(v => !successCID.includes(v.CID));\\n    let failName = failTeam.map(item => item.title);\\n    let batchTeam = failTeam.map(item => item.CID);\\n\\n    if (failTeam.length > 0 && status !== \\\"1\\\") {\\n        putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n        putMyVar(MY_ID + \\\":status\\\", \\\"3\\\");\\n        putLog(\\\"下载失败:[\\\" + failName.join(\\\"]，[\\\") + \\\"]。\\\");\\n        updateItem({\\n            title: \\\"[处理失败]\\\",\\n            extra: {\\n                id: MY_ID + \\\"||下载控制\\\"\\n            }\\n        });\\n    } else if (failTeam.length > 0 && status === \\\"1\\\") {\\n        putMyVar(MY_ID + \\\":batchTeam\\\", JSON.stringify(batchTeam));\\n        putMyVar(MY_ID + \\\":status\\\", \\\"4\\\");\\n        putLog(\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\");\\n        updateItem({\\n            title: \\\"[重新开始]\\\",\\n            extra: {\\n                id: MY_ID + \\\"||下载控制\\\"\\n            }\\n        });\\n    } else {\\n        putMyVar(MY_ID + \\\":status\\\", \\\"2\\\");\\n        putLog(\\\"下载任务[\\\" + info.bookName + \\\"]已全部成功完成\\\");\\n        updateItem({\\n            title: \\\"[返回]\\\",\\n            extra: {\\n                id: MY_ID + \\\"||下载控制\\\"\\n            }\\n        });\\n    }\\n    return \\\"hiker://empty\\\";\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.批量主程序\",\"path\":\"Batch.exe.js\",\"rule\":\"const Mian = $.require(\\\"mainDownload\\\");\\nfunction comic(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    return Mian.comic(chapterItem, info, chapterItem.CID, MY_ID, true)||chapterItem.CID;\\n}\\n\\nfunction novel(taskParam) {\\n    let {\\n        chapterItem,\\n        info,\\n        MY_ID,\\n    } = taskParam;\\n    return Mian.novel(chapterItem, info, chapterItem.CID,MY_ID, true)||chapterItem.CID;\\n    //File.renameFile(chapterPath, chapterItem.CID + \\\"$A$\\\" + chapterItem.title);\\n}\\nvar $exe = {\\n    comic: comic,\\n    novel: novel\\n};\\n$.exports = function(taskParam) {\\n    return $exe[taskParam.info.type](taskParam);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.普通主程序\",\"path\":\"Download.exe.js\",\"rule\":\"const Mian = $.require(\\\"mainDownload\\\");\\nfunction novel(item, info, order, MY_ID) {\\n    Mian.novel(item, info, order);\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\n\\nfunction comic(item, info, order, MY_ID) {\\n    Mian.comic(item, info, order);\\n    return \\\"toast://\\\" + info.bookName + \\\"@\\\" + item.title + \\\" 下载完成\\\";\\n}\\nvar $exe = {\\n    comic: comic,\\n    novel: novel\\n};\\n$.exports = function(item, info, order, MY_ID) {\\n    return $exe[info.type](item, info, order, MY_ID);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"#f.通用工具\",\"path\":\"Tool.js\",\"rule\":\"const v = {\\n    split(text, target, count) {\\n        count = count === undefined ? 1 : count;\\n        let array = [text];\\n        for (let i = 0; i < count; i++) {\\n            text = array[i];\\n            let index = text.indexOf(target);\\n            if (index === -1) {\\n                break;\\n            }\\n            array[i] = text.slice(0, index);\\n            array[i + 1] = text.slice(index + target.length);\\n        }\\n        return array;\\n    },\\n    chunk(arr, size) {\\n        var result = [];\\n        for (var i = 0, len = arr.length; i < len; i += size) {\\n            result.push(arr.slice(i, i + size));\\n        }\\n        return result;\\n    },\\n    hikerPic(url) {\\n        var headers = {};\\n        let urls = url.split(\\\"@\\\");\\n        let picUrl = urls.shift();\\n        let length = urls.length;\\n        for (let i = 0; i < length; i++) {\\n            let [key, value] = v.split(urls[i], \\\"=\\\");\\n            if (key === \\\"headers\\\") {\\n                try {\\n                    Object.assign(headers, JSON.parse(value));\\n                } catch (e) {\\n                    log(e.toString());\\n                }\\n            } else if (key.includes(\\\".\\\") || key.includes(\\\"?\\\")) {\\n                picUrl += \\\"@\\\" + key + (value ? \\\"=\\\" + value : \\\"\\\");\\n            } else if (key !== \\\"js\\\") {\\n                headers[key] = value;\\n            }\\n        }\\n        return [picUrl, headers];\\n    },\\n    range(start, end) {\\n        return Array(end - start).fill(0).map((el, i) => start + i);\\n    },\\n    picDownload(url, path, headers, deciphe) {\\n        if (typeof deciphe === \\\"string\\\" && deciphe.length > 0) {\\n            let instream;\\n            let outstream;\\n            let file;\\n            try {\\n                file = new java.io.File(path);\\n                if (file.exists()) {\\n                    return;\\n                }\\n                let dir = file.getParentFile();\\n                if (dir != null && !dir.exists()) {\\n                    dir.mkdirs();\\n                }\\n                instream = fetch(url, {\\n                    headers: headers,\\n                    inputStream: true\\n                });\\n\\n                outstream = new java.io.FileOutputStream(path);\\n                let t = $.hiker.input,\\n                    c = $.hiker.url;\\n                $.hiker.input = instream;\\n                $.hiker.url = url;\\n                let picin = (new Function(\\\"return \\\" + deciphe))();\\n                $.hiker.input = t;\\n                $.hiker.url = c;\\n                let buf = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 1024);\\n                let len;\\n                while ((len = picin.read(buf)) != -1) {\\n                    outstream.write(buf, 0, len);\\n                }\\n                closeMe(instream);\\n                closeMe(outstream);\\n            } catch (e) {\\n                closeMe(instream);\\n                closeMe(outstream);\\n                if (file instanceof java.io.File && file.exists()) {\\n                    file.delete();\\n                }\\n                log(\\\"<解密下载Error>\\\" + e.toString())\\n                throw e;\\n            } finally {\\n                closeMe(instream);\\n                closeMe(outstream);\\n            }\\n\\n        } else {\\n            requireDownload(url, path, headers);\\n        }\\n    },\\n    textShield(text) {\\n        let e = /#|:|&|\\\\||\\\\^|@|\\\\<|\\\\>|%|\\\\/|\\\\?|\\\\$/g;\\n        return text.replace(e, \\\"_\\\");\\n    }\\n    \\n}\\n\\n$.exports = v;\"},{\"col_type\":\"movie_3\",\"name\":\"#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.js\\\");\\n    let type = getMyVar(\\\".type\\\", getItem(\\\"main:type\\\", Config.def_Lord_Type));\\n    let tgnum = getMyVar(\\\".tgnum\\\", \\\"0\\\");\\n    addListener(\\\"onClose\\\", $.toString((MY_ID) => {\\n        clearMyVar(\\\"searchKey\\\");\\n        clearMyVar(\\\".tgnum\\\");\\n    }));\\n    layout.push({\\n        title: type === \\\"comic\\\" ? \\\"◉漫画\\\" : \\\"○漫画\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((type) => {\\n            if (type === \\\"comic\\\") return \\\"hiker://empty\\\";\\n            putMyVar(\\\".type\\\", \\\"comic\\\");\\n            setItem(\\\"main:type\\\", \\\"comic\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_3\\\",\\n    });\\n    layout.push({\\n        title: type === \\\"novel\\\" ? \\\"◉小说\\\" : \\\"○小说\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((type) => {\\n            if (type === \\\"novel\\\") return \\\"hiker://empty\\\";\\n            putMyVar(\\\".type\\\", \\\"novel\\\");\\n            setItem(\\\"main:type\\\", \\\"novel\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_3\\\",\\n    });\\n    layout.push({\\n        title: type === \\\"txt\\\" ? \\\"◉整本小说\\\" : \\\"○整本小说\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((type) => {\\n            if (type === \\\"txt\\\") return \\\"hiker://page/NovelCollected.view#noRecordHistory##noHistory#\\\";\\n            putMyVar(\\\".type\\\", \\\"txt\\\");\\n            setItem(\\\"main:type\\\", \\\"txt\\\");\\n            clearMyVar(\\\".tgnum\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, type),\\n        col_type: \\\"text_3\\\"\\n    });\\n    if (type === \\\"txt\\\") {\\n        let txtView = $.require(\\\"hiker://page/externalimportTxt.view\\\");\\n        return txtView(layout);\\n    }\\n    let tag = File.getFilePath(Config[type + \\\"Path\\\"], \\\"dir\\\");\\n    if (tag.length === 0) {\\n        layout.push({\\n            col_type: \\\"line_blank\\\",\\n        });\\n        layout.push({\\n            title: \\\"设置\\\",\\n            url: \\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\",\\n            col_type: \\\"text_2\\\",\\n            extra: {\\n                version: MY_RULE.version\\n            }\\n        });\\n\\n        layout.push({\\n            title: \\\"““帮助””\\\",\\n            url: \\\"hiker://page/help.view#noRefresh##noRecordHistory##noHistory#?keyword=novelComic\\\",\\n            col_type: \\\"text_2\\\"\\n        });\\n        layout.push({\\n            title: '<h1 style=\\\"text-align: center;\\\">啥都没有耶</h1>',\\n            col_type: \\\"rich_text\\\"\\n        });\\n        return setResult(layout);\\n    }\\n    layout.push({\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        desc: \\\"搜你想要的#\\\" + type + \\\"#......\\\",\\n        title: \\\"🔍\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            rules: $.toString((tag, type) => {\\n                let arr1 = [];\\n                for (let i = 0; i < tag.length; i++) {\\n                    arr1.push({\\n                        \\\"title\\\": tag[i].name,\\n                        \\\"search_url\\\": \\\"hiker://empty?isAll=1&searchTerms=**&type=\\\" + type,\\n                        \\\"searchFind\\\": \\\"js:$.require('hiker://page/Search.view?rule='+MY_RULE._title);\\\"\\n                    });\\n                }\\n\\n                return JSON.stringify(arr1);\\n            }, tag, type),\\n            defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"\\n        }\\n    });\\n\\n    layout.push({\\n        title: \\\"‘‘⚙设置’’\\\",\\n        col_type: \\\"scroll_button\\\",\\n        url: \\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\",\\n        extra: {\\n            version: MY_RULE.version\\n        }\\n    });\\n\\n\\n    for (let i in tag) {\\n        let it = tag[i];\\n        if (tgnum === i) {\\n            layout.push({\\n                title: \\\"““\\\" + it.name + \\\"””\\\",\\n                col_type: \\\"scroll_button\\\",\\n                url: $([\\\"删除该目录\\\", \\\"跳转小程序\\\", \\\"打开书架\\\"], 1, \\\"选择操作\\\").select((it, type) => {\\n                    if (\\\"跳转小程序\\\" === input) {\\n                        return \\\"hiker://home@\\\" + it.name;\\n                    } else if(\\\"删除该目录\\\"===input){\\n                        //return then([\\\"该操作不会删除小程序，但该小程序下载的所有漫画将被删除\\\"]);\\n                        return $(\\\"该操作不会删除小程序，但该小程序下载的所有 漫画/小说 将被删除\\\").confirm((path) => {\\n                            const File = $.require(\\\"hiker://page/File.js\\\");\\n                            if (File.deleteFiles(path)) {\\n                                clearMyVar(\\\".tgnum\\\");\\n                                refreshPage();\\n                                return \\\"toast://删除成功\\\";\\n                            } else {\\n                                return \\\"toast://删除失败\\\";\\n                            }\\n                        }, it.path);\\n                    }else{\\n                        return \\\"hiker://page/Bookrack.view?rule=本地资源管理&ruleName=\\\"+it.name+\\\"&type=\\\"+type;\\n                    }\\n                }, it, type)\\n            });\\n        } else {\\n            layout.push({\\n                title: it.name,\\n                col_type: \\\"scroll_button\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule(i => {\\n                    putMyVar(\\\".tgnum\\\", i);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }, i),\\n            });\\n        }\\n    }\\n    let path = tag[tgnum].path;\\n    let mhlist = File.getFilePath(path, \\\"dir\\\");\\n\\n    if (mhlist.length === 0) {\\n        layout.push({\\n            title: \\\"““””\\\" + \\\"啥都没有耶\\\".big(),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n        return setResult(layout);\\n    }\\n    let pageUrl = type === \\\"novel\\\" ? \\\"hiker://page/NovelBrowser.view\\\" : \\\"hiker://page/ComicBrowser.view\\\";\\n    for (let item of mhlist) {\\n        let pic = fileExist(\\\"file://\\\" + item.path + \\\"/\\\" + item.name + \\\".jpg\\\") ? item.path + \\\"/\\\" + item.name + \\\".jpg\\\" : Config.def_Pic;\\n        let names=String(item.name).split(\\\"$\\\");\\n        layout.push({\\n            title: names[0],\\n            desc: names[1],\\n            pic_url: pic,\\n            url: type === \\\"novel\\\" ?pageUrl + \\\"?rule=\\\" + MY_RULE.title:$(\\\"#noLoading#\\\").lazyRule((pageUrl, path)=>{\\n                return $.require(\\\"longPress.js\\\").singleEnter(pageUrl, path);\\n            }, pageUrl, item.path),\\n            extra: Object.assign(item, {\\n                longClick: [{\\n                    title: \\\"删除\\\",\\n                    js: $.toString((path) => {\\n                        return $.require(\\\"longPress.js\\\").deleteFileForBook(path)\\n                    }, item.path)\\n                }],\\n                id: item.path\\n            })\\n        });\\n    }\\n    setResult(layout);\\n}\\n\\nmain();\"},{\"col_type\":\"text_1\",\"name\":\"#v.漫画章节列表\",\"path\":\"ComicBrowser.view\",\"rule\":\"js:\\nconst Tool = $.require(\\\"Tool.js\\\");\\nconst Config = $.require(\\\"Config.js\\\");\\nconst File = $.require(\\\"File.js\\\");\\nif (getParam(\\\"hasParams\\\") === \\\"true\\\") {\\n    MY_PARAMS = {\\n        path: decodeURIComponent(getParam(\\\"path\\\")),\\n        name: decodeURIComponent(getParam(\\\"name\\\")),\\n        bookName: decodeURIComponent(getParam(\\\"bookName\\\")),\\n        ruleName: decodeURIComponent(getParam(\\\"ruleName\\\")),\\n        comicStyle: getParam(\\\"comicStyle\\\")\\n    }\\n}\\nlet path = MY_PARAMS.path;\\nif (!path) {\\n    path = Config.comicPath + \\\"/\\\" + MY_PARAMS.ruleName + \\\"/\\\" + MY_PARAMS.bookName;\\n}\\nif (MY_PARAMS.comicStyle) {\\n    Config.def_Comic_Style = MY_PARAMS.comicStyle;\\n}\\nsetPageTitle(\\\"CV|\\\" + (MY_PARAMS.name || File.getName(path)));\\n\\nvar layout = [];\\nlet mode = getMyVar(\\\".mode\\\", \\\"0\\\");\\nlet isReverse = getMyVar(\\\".isReverse\\\", \\\"0\\\");\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\".mode\\\");\\n    clearMyVar(\\\".isReverse\\\");\\n}));\\nconst comicStatus = new Map([\\n    [\\\"A\\\", \\\"\\\"],\\n    [\\\"B\\\", \\\"‘‘[未完成]’’\\\"]\\n]);\\n\\nfunction getTitle(title) {\\n    let titles = Tool.split(title, \\\"$\\\", 2);\\n    return comicStatus.get(titles[1]) + titles[2] || title;\\n}\\n\\nfunction getTitle2(title) {\\n    let titles = Tool.split(title, \\\"$\\\", 2);\\n    return titles[2] || title;\\n}\\nlayout.push({\\n    title: \\\"删除整本\\\",\\n    url: $(\\\"确认删除整本漫画？\\\").confirm((path) => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFiles(path)) {\\n            back();\\n            return \\\"toast://删除成功\\\";\\n        } else {\\n            return \\\"toast://删除失败\\\";\\n        }\\n    }, path),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    title: [\\\"看漫画\\\", \\\"删除章节\\\"][mode],\\n    url: $(\\\"#noLoading#\\\").lazyRule((mode) => {\\n        putMyVar(\\\".mode\\\", mode === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage(true);\\n        return \\\"hiker://empty\\\"\\n    }, mode),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n})\\nlet mhlist = File.getFilePath(path, \\\"dir\\\");\\nmhlist.sort((a, b) => {\\n    a = (a.name.match(/\\\\d+/) || [])[0] || 0;\\n    b = (b.name.match(/\\\\d+/) || [])[0] || 0;\\n    return a - b;\\n});\\n\\nlayout.push({\\n    title: \\\"““””\\\" + \\\"章节 \\\".big() + (\\\"共有:\\\" + mhlist.length + \\\"章\\\").small(),\\n    url: $(\\\"#noLoading#\\\").lazyRule((isReverse) => {\\n        putMyVar(\\\".isReverse\\\", isReverse === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage(true);\\n        return \\\"hiker://empty\\\"\\n    }, isReverse),\\n    col_type: \\\"text_1\\\"\\n});\\nlet array = [];\\n\\nif (mode === \\\"0\\\") {\\n    if (Config.def_isComicCompatible === \\\"0\\\") {\\n        let lazy = $(\\\"#noLoading#\\\").lazyRule(() => {\\n            const File = $.require(\\\"hiker://page/File.js\\\");\\n            let filelist = File.getFilePath(input);\\n            let shorten = input.replace(getPath(\\\"hiker://files/\\\").slice(7), \\\"hiker://files/\\\");\\n            let piclist = filelist.map((item, i) => shorten + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n            return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n        });\\n        for (let item of mhlist) {\\n            let title = getTitle(item.name);\\n            array.push({\\n                title: title,\\n                url: item.path + lazy,\\n                col_type: Config.def_Comic_Style,\\n                pic_url: item.path + \\\"/1.jpg\\\"\\n            });\\n        }\\n    } else {\\n        for (let item of mhlist) {\\n            let title = getTitle(item.name);\\n            array.push({\\n                title: title,\\n                url: \\\"hiker://page/comicCompatible.view#autoPage##readTheme#?path=\\\" + encodeURIComponent(item.path),\\n                col_type: Config.def_Comic_Style,\\n                pic_url: item.path + \\\"/1.jpg\\\",\\n                extra: {\\n                    path: item.path,\\n                    title: getTitle2(item.name)\\n                }\\n            });\\n        }\\n    }\\n\\n} else {\\n    for (let item of mhlist) {\\n        let name = getTitle2(item.name);\\n        array.push({\\n            title: name,\\n            url: $(\\\"确认删除[\\\" + name + \\\"]？\\\").confirm((path) => {\\n                const File = $.require(\\\"hiker://page/File.js\\\");\\n                if (File.deleteFiles(path)) {\\n                    refreshPage(true);\\n                    return \\\"toast://删除成功\\\";\\n                } else {\\n                    return \\\"toast://删除失败\\\";\\n                }\\n            }, item.path),\\n            col_type: Config.def_Comic_Style,\\n            pic_url: item.path + \\\"/1.jpg\\\"\\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.js?rule=\\\" + MY_RULE._title);\\nlet comicRuleDirs = File.getFilePath(Config[getParam(\\\"type\\\") + \\\"Path\\\"], \\\"dir\\\");\\nif (getParam(\\\"isAll\\\") === \\\"1\\\") {\\n    comicRuleDirs = comicRuleDirs.filter(item => item.name === MY_RULE.title);\\n}\\n\\nlet searchResult = [];\\nlet searchTerms= getParam(\\\"searchTerms\\\");\\nlet searchTest;\\n\\nif (!getSearchMode()) {\\n    let termsArr = searchTerms.split(\\\"\\\").map(t => t.replace(/\\\\*|\\\\.|\\\\?|\\\\+|\\\\$|\\\\^|\\\\[|\\\\]|\\\\(|\\\\)|\\\\{|\\\\}|\\\\||\\\\/|\\\\\\\\/g, k => \\\"\\\\\\\\\\\" + k));\\n    let reg = new RegExp(termsArr.join(\\\".*\\\"), \\\"i\\\");\\n    searchTest = text => reg.test(text);\\n} else {\\n    searchTest = text => searchContains(text, searchTerms, false);\\n}\\n\\nlet pageUrl = getParam(\\\"type\\\") === \\\"novel\\\" ? \\\"hiker://page/NovelBrowser.view\\\" : \\\"hiker://page/ComicBrowser.view\\\";\\nfor (let sonDir of comicRuleDirs) {\\n    let comicList = File.getFilePath(sonDir.path, \\\"dir\\\");\\n    for (let comic of comicList) {\\n        if (searchTest(comic.name)) {\\n            searchResult.push({\\n                title: comic.name,\\n                pic_url: comic.path + \\\"/\\\" + comic.name + \\\".jpg\\\",\\n                url: pageUrl + \\\"?rule=\\\" + MY_RULE._title,\\n                desc: sonDir.name,\\n                extra: comic\\n            });\\n        }\\n    }\\n\\n}\\nsetResult(searchResult);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.设置\",\"path\":\"Setting.view\",\"rule\":\"js:\\nsetPageTitle(MY_RULE.title + \\\"|设置\\\");\\nconst Config = $.require(\\\"hiker://page/Config.js\\\");\\n\\nlet layout = [];\\n\\nlayout.push({\\n    title: \\\"<strong>基础设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"目录路径\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRefresh##noRecordHistory##noHistory#?settingType=contents\\\",\\n    desc: Config.homePath,\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"设置默认封面\\\",\\n    desc: Config.def_Pic,\\n    url: \\\"hiker://page/Setting/More.view#noRefresh##noRecordHistory##noHistory#?settingType=defaultPic\\\",\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"<strong>下载器设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nfunction setNum(key, test) {\\n    let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n    input = parseInt(input);\\n    if (Number.isNaN(input)) return \\\"toast://请输入数字\\\";\\n    if (!test(input)) return \\\"toast://不符合条件\\\";\\n    Config[key] = input;\\n    saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n    refreshPage(false);\\n    return \\\"toast://修改成功\\\";\\n}\\nlayout.push({\\n    title: \\\"log数\\\",\\n    url: $(Config.logNum, \\\"0<N<100\\\").input(setNum, \\\"logNum\\\", it => it > 0 && it < 100),\\n    desc: \\\"\\\" + Config.logNum,\\n    col_type: \\\"text_1\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"分批下载数(0不开启)\\\",\\n    url: $(\\\"\\\" + Config.threadNum, \\\"N>-1\\\").input(setNum, \\\"threadNum\\\", it => it > -1),\\n    desc: \\\"\\\" + Config.threadNum,\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        lineVisible: false,\\n    }\\n});\\n\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"<strong>小说阅读器设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"默认开启分页阅读\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((def_isPaginate) => {\\n        let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n\\n        Config.def_isPaginate = def_isPaginate === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\";\\n\\n        saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, Config.def_isPaginate),\\n    desc: Config.def_isPaginate === \\\"0\\\" ? \\\"不开启\\\" : \\\"开启\\\",\\n    col_type: \\\"text_1\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"每页最大章数\\\",\\n    url: $(Config.viewPageSize, \\\"30<N<500\\\").input(setNum, \\\"viewPageSize\\\", it => it > 30 && it < 500),\\n    desc: \\\"\\\" + Config.viewPageSize,\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"替换规则\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRecordHistory##noHistory##noRefresh#?settingType=replaceRule\\\",\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"<strong>漫画阅读器设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    title: \\\"兼容模式\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((def_isComicCompatible) => {\\n        let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n\\n        Config.def_isComicCompatible = def_isComicCompatible === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\";\\n\\n        saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, Config.def_isComicCompatible),\\n    desc: Config.def_isComicCompatible === \\\"0\\\" ? \\\"不开启\\\" : \\\"开启\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"漫画列表样式\\\",\\n    url: $([\\\"text_1\\\", \\\"avatar\\\", \\\"pic_3\\\", \\\"pic_3_square\\\", \\\"movie_3_marquee\\\"], 1, \\\"请选择漫画列表显示样式\\\").select(() => {\\n        let Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n        Config.def_Comic_Style = input;\\n        saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, Config.def_Comic_Style),\\n    desc: Config.def_Comic_Style||\\\"\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"<strong>其他设置</strong>\\\".big(),\\n    col_type: \\\"rich_text\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    title: \\\"规则发布页\\\",\\n    url: \\\"hiker://page/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\",\\n    extra: {\\n        lver: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\",\\n        id: \\\"3559\\\"\\n    },\\n    col_type: \\\"text_1\\\"\\n});\\n\\nlayout.push({\\n    title: \\\"恢复默认设置\\\",\\n    url: $(\\\"确认恢复默认设置？\\\").confirm(() => {\\n        deleteFile(\\\"config.json\\\");\\n        refreshPage(false);\\n        return \\\"toast://恢复完成\\\";\\n    }),\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"清理缓存\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRecordHistory##noHistory#?settingType=cache\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"文件管理\\\",\\n    url: \\\"hiker://page/FileManagement.view#noRefresh##noRecordHistory##noHistory#\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlet tid = Date.now();\\nlayout.push({\\n    title: \\\"检测更新\\\",\\n    col_type: \\\"text_1\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((oldVersion, tid) => {\\n        try {\\n            let newVersion = JSON.parse(request(\\\"http://hiker.nokia.press/hikerule/dev/getbyid?id=3559\\\", {\\n                timeout: 2000\\n            })).result.ver;\\n            if (newVersion <= oldVersion) {\\n                updateItem(tid + \\\"#设置_更新\\\", {\\n                    title: \\\"已经是最新版本了\\\"\\n                });\\n                return \\\"toast://已经是最新版本了\\\";\\n            } else {\\n                updateItem(tid + \\\"#设置_更新\\\", {\\n                    title: \\\"有新版本还未更新\\\"\\n                });\\n                toast(\\\"有新版本还未更新\\\");\\n                return \\\"rule://5rW36ZiU6KeG55WM77+laG9tZV9ydWxlX3VybO+/pWh0dHA6Ly9oaWtlci5ub2tpYS5wcmVzcy9oaWtlcnVsZS9ydWxlbGlzdC5qc29uP2lkPTM1NTk=\\\";\\n            }\\n        } catch (e) {\\n            updateItem(tid + \\\"#设置_更新\\\", {\\n                title: \\\"信息获取失败\\\"\\n            });\\n            return \\\"toast://更新信息获取失败\\\";\\n        }\\n    }, MY_PARAMS.version, tid),\\n    extra: {\\n        id: tid + \\\"#设置_更新\\\"\\n    }\\n});\\nlayout.push({\\n    title: \\\"关于如何调用\\\",\\n    url: \\\"mqqapi://forward/url?src_type=web&style=default&plg_auth=1&version=1&url_prefix=aHR0cHM6Ly9xdW4ucXEuY29tL3Fxd2ViL3F1bnByby9zaGFyZT9fd3Y9MyZfd3d2PTEyOCZpbnZpdGVDb2RlPTFIRnlCSiZmcm9tPTI0NjYxMCZiaXo9a2EjL291dA==\\\",\\n    desc: \\\"详细点击加入频道(快来华山与我论[ji]剑)\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nlayout.push({\\n    title: \\\"问题反馈\\\",\\n    url: \\\"mqqapi://forward/url?src_type=web&style=default&plg_auth=1&version=1&url_prefix=aHR0cHM6Ly9xdW4ucXEuY29tL3Fxd2ViL3F1bnByby9zaGFyZT9fd3Y9MyZfd3d2PTEyOCZhcHBDaGFubmVsPXNoYXJlJmludml0ZUNvZGU9MVhOYWxBRXl2VmomY29udGVudElEPWMzbElQJmJ1c2luZXNzVHlwZT0yJmZyb209MTgxMDc0JmJpej1rYSZtYWluU291cmNlSWQ9c2hhcmUmc3ViU291cmNlSWQ9b3RoZXJzJmp1bXBzb3VyY2U9c2hvcnR1cmw=&t=1671893123597#Intent;scheme=mqqapi;package=com.tencent.mobileqq;end\\\",\\n    desc: \\\"绝对不会有bug(啊我不接受!)\\\",\\n    col_type: \\\"text_1\\\"\\n});\\n/*\\nlayout.push({\\n    title: \\\"清除小说分页记录\\\",\\n    url: $(\\\"确认清除小说分页记录？\\\").confirm(() => {\\n        deleteFile(\\\"novelFootprint.json\\\");\\n        return \\\"toast://清除完成\\\";\\n    }),\\n    col_type: \\\"text_1\\\"\\n});\\n*/\\nsetResult(layout);\"},{\"col_type\":\"text_1\",\"name\":\"#v.小说章节列表\",\"path\":\"NovelBrowser.view\",\"rule\":\"js:\\nif (getParam(\\\"hasParams\\\") === \\\"true\\\") {\\n    MY_PARAMS = {\\n        path: decodeURIComponent(getParam(\\\"path\\\")),\\n        name: decodeURIComponent(getParam(\\\"name\\\"))\\n    }\\n}\\nlet path = MY_PARAMS.path;\\nsetPageTitle(\\\"NV|\\\" + MY_PARAMS.name);\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.js\\\");\\nconst bookInfo = Object.assign({\\n    foot: 0,\\n    isReplace: true,\\n    isSegment: 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.js\\\");\\n\\n    let filelist = File.getFilePath(paths.path, \\\"file\\\", \\\".txt\\\");\\n    let listLength = filelist.length;\\n    if (listLength === 0) {\\n        hideLoading();\\n        return \\\"toast://空的章节\\\";\\n    }\\n    const bookInfo = Object.assign({\\n        selected: [],\\n        isReplace: true\\n    }, JSON.parse(request(\\\"file://\\\" + paths.path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\n    let bufilelist = [];\\n    for (let i = 0; i < listLength; i++) {\\n        let file = filelist[i];\\n        let fileInfo = Tool.split(file.name, \\\"$\\\", 2);\\n        bufilelist.push({\\n            name: fileInfo[2].slice(0, fileInfo[2].lastIndexOf(\\\".\\\")),\\n            path: \\\"file://\\\" + file.path,\\n            id: Number(fileInfo[0]) || 0\\n        });\\n    }\\n    bufilelist.sort((a, b) => a.id - b.id);\\n    let entirePath = paths.path.replace(Config.novelPath, Config.novelFullPath) + \\\".txt\\\";\\n    let entirePathto = bookInfo.isReplace ? entirePath + \\\".tmp\\\" : entirePath;\\n\\n    if (fileExist(\\\"file://\\\" + entirePath)) {\\n        toast(\\\"初始化文件\\\");\\n        if (!File.deleteFiles(entirePath)) {\\n            hideLoading();\\n            return \\\"toast://初始化失败\\\";\\n        } else {\\n            toast(\\\"初始化成功\\\");\\n        }\\n    }\\n\\n    for (let i = 0; i < listLength; i++) {\\n        let item = bufilelist[i];\\n        let content = request(item.path);\\n        File.fileWriteAppend(entirePathto, item.name + \\\"\\\\n　　\\\" + content.replace(/&nbsp;/g,\\\"\\\").split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it=>it.trim()).join(\\\"\\\\r　　\\\") + \\\"\\\\n\\\\n\\\");\\n    }\\n    if (bookInfo.isReplace) {\\n        let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n        let len = ruleList.length;\\n        let replacePattern = [\\\"replace\\\", \\\"replaceAll\\\"];\\n        let flag = File.fileRule(entirePathto, entirePath, (javaString) => {\\n            for (let i = 0; i < len; i++) {\\n                let replaceRule = ruleList[i];\\n                if (!bookInfo.selected.includes(replaceRule.id)) {\\n                    continue;\\n                }\\n                let replace = replacePattern[0 + replaceRule.isRegex];\\n                javaString = javaString[replace](replaceRule.pattern, replaceRule.replacement);\\n            }\\n            return javaString.getBytes();\\n        });\\n        if (!flag) {\\n            hideLoading();\\n            return \\\"toast://合并失败\\\";\\n        }\\n\\n    }\\n    hideLoading();\\n    return \\\"toast://合并完成\\\";\\n}\\nlayout.push({\\n    title: \\\"合并小说\\\",\\n    url: $(\\\"确定合并?\\\\n会覆盖已有TXT\\\").confirm(txt, MY_PARAMS),\\n    col_type: \\\"scroll_button\\\"\\n});\\nlayout.push({\\n    title: [\\\"☐分页\\\", \\\"☑分页\\\"][mode2],\\n    url: $(\\\"#noLoading#\\\").lazyRule((mode2) => {\\n        putMyVar(\\\".mode2\\\", mode2 === \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage(true);\\n        return \\\"hiker://empty\\\";\\n    }, mode2),\\n    col_type: \\\"scroll_button\\\"\\n});\\nlayout.push({\\n    title: [\\\"☐分段\\\", \\\"☑分段\\\"][Number(bookInfo.isSegment)],\\n    url: $(\\\"#noLoading#\\\").lazyRule((isSegment, path) => {\\n        const bookInfo = JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n        bookInfo.isSegment = !isSegment;\\n        writeFile(\\\"file://\\\" + path+\\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, bookInfo.isSegment, path),\\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.js\\\");\\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: false,\\n    isSegment: 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}\\nif (bookInfo.isSegment) {\\n    content = \\\"　　\\\" + content.split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it => it.trim()).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.js\\\");\\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.js\\\");\\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        }else{\\n            layout.push({\\n                title: \\\"图片late\\\",\\n                col_type: \\\"movie_3\\\",\\n                pic_url: \\\"hiker://images/home_late\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule(setDefaultPic, \\\"hiker://images/home_late\\\")\\n            });\\n        }\\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                        fileType: \\\".jpg|.jpeg|.gif|.png|.svg|.bmp\\\",\\n                        onClickType: \\\"confirm\\\",\\n                        store: \\\"selectPathCache2\\\",\\n                        memoryPath: true\\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 = [];\\n        try {\\n            ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n        } catch (e) {\\n            confirm({\\n                title: '错误提示',\\n                content: '替换数据读取失败，是否初始化？\\\\n该操作会清除你的替换数据!!!',\\n                confirm: $.toString(() => {\\n                    deleteFile(\\\"replaceRule.json\\\");\\n                    toast(\\\"初始化完成\\\");\\n                }),\\n                cancel: $.toString(() => {\\n                    //toast(\\\"取消\\\");\\n                })\\n            })\\n        }\\n        layout.push({\\n            title: \\\"新建替换\\\",\\n            url: \\\"hiker://page/editReplaceRule.view#noRecordHistory##noHistory##noRefresh#?isNew=true\\\",\\n            col_type: \\\"text_3\\\"\\n        });\\n        layout.push({\\n            title: \\\"导出规则\\\",\\n            url: $(\\\"确认导出\\\" + ruleList.length + \\\"条规则？\\\\n({homePtah}/replaceRule.json)\\\").confirm((num) => {\\n                const Config = $.require(\\\"hiker://page/Config.js\\\");\\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.js\\\");\\n                if (input.startsWith(\\\"hiker://files/\\\")) input = getPath(input).slice(7);\\n                if (input.endsWith(\\\"/\\\")) input = input.replace(/\\\\/$/, \\\"\\\");\\n                if (Config.homePath == input) return \\\"toast://已经是当前目录\\\";\\n                Config = JSON.parse(readFile(\\\"config.json\\\", 0) || \\\"{}\\\");\\n                Config.homePath = input;\\n                saveFile(\\\"config.json\\\", JSON.stringify(Config), 0);\\n                back();\\n                return \\\"toast://已保存\\\";\\n            }, id),\\n            col_type: \\\"text_center_1\\\",\\n        });\\n\\n        break;\\n}\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.编辑替换规则\",\"path\":\"editReplaceRule.view\",\"rule\":\"js:\\nconst isNew = MY_PARAMS.isNew || getParam(\\\"isNew\\\");\\nconst index = MY_PARAMS.index || Number(getParam(\\\"index\\\"));\\nlet layout = [];\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\".editReplaceRule.name\\\");\\n    clearMyVar(\\\".editReplaceRule.isRegex\\\");\\n    clearMyVar(\\\".editReplaceRule.pattern\\\");\\n    clearMyVar(\\\".editReplaceRule.replacement\\\");\\n    clearMyVar(\\\".editReplaceRule.first\\\");\\n    //clearMyVar(\\\".editReplaceRule.scope\\\");\\n}));\\nlet ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\nlet id = \\\"#\\\" + new Date().getTime();\\n//let replaceRule = isNew == \\\"true\\\"?{}:ruleList[index];\\nif (isNew == \\\"true\\\") {\\n    replaceRule = {\\n        id: new Date().getTime(),\\n        isRegex: false,\\n    }\\n} else {\\n    replaceRule = ruleList[index];\\n}\\n//首次初始化\\nif(getMyVar(\\\".editReplaceRule.first\\\",\\\"\\\")==\\\"\\\"){\\n    putMyVar(\\\".editReplaceRule.isRegex\\\", \\\"\\\" + replaceRule.isRegex);\\n    putMyVar(\\\".editReplaceRule.first\\\",\\\"1\\\");\\n}\\nlayout.push({\\n    title: \\\"拷贝\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let att = [\\\"name\\\", \\\"isRegex\\\", \\\"pattern\\\", \\\"replacement\\\"];\\n        let json = {};\\n        att.forEach(key => {\\n            let value = getMyVar(\\\".editReplaceRule.\\\" + key, \\\"\\\");\\n            if (key === \\\"isRegex\\\") {\\n                value = value === \\\"true\\\" ? true : false;\\n            }\\n            json[key] = value;\\n        });\\n        copy(JSON.stringify(json));\\n        return \\\"hiker://empty\\\";\\n    }),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    title: \\\"粘贴\\\",\\n    url: $(\\\"{{clipboard}}\\\").input(() => {\\n        try {\\n            let json = JSON.parse(input);\\n            if (Array.isArray(json) || json.pattern == undefined) return;\\n            let att = [\\\"name\\\", \\\"isRegex\\\", \\\"pattern\\\", \\\"replacement\\\"];\\n            att.forEach(key => {\\n                putMyVar(\\\".editReplaceRule.\\\" + key, String(json[key]));\\n            });\\n            refreshPage(false);\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }),\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换规则名称\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getMyVar(\\\".editReplaceRule.name\\\", replaceRule.name),\\n        onChange: 'putMyVar(\\\".editReplaceRule.name\\\",input);'\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换规则\\\",\\n    extra: {\\n        titleVisible: false,\\n        type: \\\"textarea\\\",\\n        height: -1,\\n        defaultValue: getMyVar(\\\".editReplaceRule.pattern\\\", replaceRule.pattern),\\n        onChange: 'putMyVar(\\\".editReplaceRule.pattern\\\", input);'\\n    }\\n});\\nlayout.push({\\n    title: \\\"是否使用正则表达式：\\\" + getMyVar(\\\".editReplaceRule.isRegex\\\"),\\n    url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n        let isRegex = getMyVar(\\\".editReplaceRule.isRegex\\\") === \\\"true\\\" ? false : true;\\n        updateItem({\\n            extra: {\\n                id: id\\n            },\\n            title: \\\"是否使用正则表达式：\\\" + isRegex\\n        });\\n        putMyVar(\\\".editReplaceRule.isRegex\\\", \\\"\\\" + isRegex);\\n        return \\\"hiker://empty\\\";\\n    }, id),\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        id: id\\n    }\\n});\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换为\\\",\\n    extra: {\\n        titleVisible: false,\\n        type: \\\"textarea\\\",\\n        height: -1,\\n        defaultValue: getMyVar(\\\".editReplaceRule.replacement\\\", replaceRule.replacement),\\n        onChange: 'putMyVar(\\\".editReplaceRule.replacement\\\",input);'\\n    }\\n});\\nlayout.push({\\n    title: \\\"保存\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((replaceRule, isNew, index) => {\\n        let pattern = getMyVar(\\\".editReplaceRule.pattern\\\", \\\"\\\");\\n        if (!pattern) {\\n            return \\\"toast://替换规则不能为空\\\";\\n        }\\n        Object.assign(replaceRule, {\\n            name: getMyVar(\\\".editReplaceRule.name\\\", \\\"\\\"),\\n            isRegex: getMyVar(\\\".editReplaceRule.isRegex\\\") === \\\"true\\\" ? true : false,\\n            pattern: pattern,\\n            replacement: getMyVar(\\\".editReplaceRule.replacement\\\", \\\"\\\")\\n        });\\n        let ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\n        if (isNew == \\\"true\\\") {\\n            ruleList.push(replaceRule);\\n        } else {\\n            ruleList.splice(index, 1, replaceRule);\\n        }\\n        saveFile(\\\"replaceRule.json\\\", JSON.stringify(ruleList));\\n        back();\\n        return \\\"toast://保存成功\\\";\\n    }, replaceRule, isNew, index),\\n    col_type: \\\"text_center_1\\\",\\n});\\n\\n/*\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"替换范围\\\",\\n    extra: {\\n        titleVisible: false,\\n        type: \\\"textarea\\\",\\n        height: -1,\\n        defaultValue: \\\"\\\",\\n        onChange: 'putMyVar(\\\".editReplaceRule.scope\\\",input);'\\n    }\\n});\\n\\n*/\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.小说个性化净化\",\"path\":\"NovelCustom.view\",\"rule\":\"js:\\nsetPageTitle(\\\"替换规则|\\\" + MY_PARAMS.name);\\nlet ruleList = JSON.parse(readFile(\\\"replaceRule.json\\\") || \\\"[]\\\");\\nlet id = \\\"#\\\" + new Date().getTime();\\n\\nconst bookInfo = Object.assign({\\n    foot: 0,\\n    isReplace: true,\\n    selected: []\\n}, JSON.parse(request(\\\"file://\\\" + MY_PARAMS.path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\n\\nlet layout = [];\\nlayout.push({\\n    title: [\\\"☐净化\\\", \\\"☑净化\\\"][0 + bookInfo.isReplace],\\n    url: $(\\\"#noLoading#\\\").lazyRule(($id, path) => {\\n\\n        var bookInfo = JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\");\\n        let isReplace = bookInfo.isReplace===undefined?true:bookInfo.isReplace;\\n        bookInfo.isReplace = !isReplace;\\n        writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n        updateItem($id, {\\n            title: isReplace ? \\\"☐净化\\\" : \\\"☑净化\\\",\\n        });\\n        return \\\"hiker://empty\\\";\\n    }, id + \\\"#-1\\\", MY_PARAMS.path),\\n    extra: {\\n        id: id + \\\"#-1\\\"\\n    },\\n    col_type: \\\"text_2\\\"\\n});\\nlayout.push({\\n    title: \\\"编辑规则\\\",\\n    url: \\\"hiker://page/Setting/More.view#noRecordHistory##noHistory##noRefresh#?settingType=replaceRule\\\",\\n    col_type: \\\"text_2\\\",\\n    extra:{\\n        isRefresh: true\\n    }\\n});\\nfor (let i = 0, len = ruleList.length; i < len; i++) {\\n    let replaceRule = ruleList[i];\\n    let isTrue = bookInfo.selected.includes(replaceRule.id);\\n    layout.push({\\n        title: (isTrue ? \\\"●\\\" : \\\"○\\\") + replaceRule.name,\\n        col_type: \\\"text_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        y: 0,\\n        extra: {\\n            isTrue: isTrue,\\n            id: id + i,\\n            lineVisible: false\\n        }\\n    });\\n    layout.push({\\n        title: \\\"开启\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(($id, replaceRule, path) => {\\n            if (findItem($id).extra.isTrue) {\\n                return \\\"toast://已开启\\\";\\n            }\\n            const bookInfo = Object.assign({\\n                selected: []\\n            }, JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\n            bookInfo.selected.push(replaceRule.id);\\n            updateItem($id, {\\n                title: \\\"●\\\" + replaceRule.name,\\n                extra: {\\n                    isTrue: true,\\n                    id: $id,\\n                    lineVisible: false\\n                }\\n            });\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            return \\\"hiker://empty\\\";\\n        }, id + i, replaceRule, MY_PARAMS.path),\\n        col_type: \\\"text_2\\\"\\n    });\\n    layout.push({\\n        title: \\\"关闭\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(($id, replaceRule, path) => {\\n            if (!findItem($id).extra.isTrue) {\\n                return \\\"toast://已关闭\\\";\\n            }\\n            const bookInfo = Object.assign({\\n                selected: []\\n            }, JSON.parse(request(\\\"file://\\\" + path + \\\"/bookInfo.json\\\") || \\\"{}\\\"));\\n            bookInfo.selected.splice(bookInfo.selected.indexOf(replaceRule.id), 1);\\n            updateItem($id, {\\n                title: \\\"○\\\" + replaceRule.name,\\n                extra: {\\n                    isTrue: false,\\n                    id: $id,\\n                    lineVisible: false\\n                }\\n            });\\n            writeFile(\\\"file://\\\" + path + \\\"/bookInfo.json\\\", JSON.stringify(bookInfo));\\n            return \\\"hiker://empty\\\";\\n        }, id + i, replaceRule, MY_PARAMS.path),\\n        col_type: \\\"text_2\\\"\\n    });\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n}\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.外导小说\",\"path\":\"externalimportTxt.view\",\"rule\":\"js:\\nfunction txtView(layout) {\\n    const File = $.require(\\\"hiker://page/File.js\\\");\\n    const Config = $.require(\\\"hiker://page/Config.js\\\");\\n    let files = File.getFilePath(Config.externalImportPath);\\n    files = files.filter(v => /(\\\\.txt|\\\\.epub)$/.test(v.name));\\n\\n    setPageTitle(\\\"小说书架\\\");\\n    //let layout = [];\\n    layout.push({\\n        url: 'input?\\\"hiker://page/txtSearch.view#noRefresh#?searchTerms=\\\"+encodeURIComponent(input):\\\"toast://请输入小说名\\\"',\\n        desc: \\\"搜索\\\",\\n        title: \\\"🔍\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            defaultValue: getMyVar(\\\"searchKeyByTxt\\\", \\\"\\\"),\\n            onChange: \\\"putMyVar('searchKeyByTxt',input)\\\"\\n        }\\n    });\\n    layout.push({\\n        title: \\\"导入小说\\\",\\n        col_type: \\\"text_3\\\",\\n        url: $([\\\"系统选择器\\\", \\\"海阔选择器\\\"], 1, \\\"选择器类型\\\").select(() => {\\n            if (input === \\\"系统选择器\\\") {\\n                return \\\"fileSelect://\\\" + $.toString(() => {\\n                    if (!/(\\\\.txt|.epub)$/i.test(input)) {\\n                        toast(\\\"选择了错误的文件类型\\\");\\n                        return;\\n                    }\\n                    const Config = $.require(\\\"hiker://page/Config.js\\\");\\n                    let fileMatch = input.match(/\\\\/([^\\\\/]*?)(\\\\.txt|\\\\.epub)$/i);\\n                    let novelName = fileMatch[1].replace(\\\"_fileSelect_\\\", \\\"\\\");\\n                    let topath = Config.externalImportPath + novelName + fileMatch[2];\\n                    let topathCache = Config.contentsCache + novelName + fileMatch[2];\\n                    let path = input.replace(\\\"file://\\\", \\\"\\\");\\n                    if (fileExist(\\\"file://\\\" + topath)) {\\n                        confirm({\\n                            title: \\\"导入提示\\\",\\n                            content: \\\"已存在[\\\" + novelName + \\\"]是否覆盖?\\\",\\n                            confirm: $.toString((path, topath, topathCache) => {\\n                                const File = $.require(\\\"hiker://page/File.js\\\");\\n                                File.copyFile(path, topath, true);\\n                                if (fileExist(\\\"file://\\\" + topathCache)) {\\n                                    File.deleteFiles(topathCache);\\n                                }\\n                                refreshPage(false);\\n                                return \\\"toast://导入成功\\\";\\n                            }, path, topath, topathCache)\\n                        });\\n                        return;\\n                    } else {\\n                        const File = $.require(\\\"hiker://page/File.js\\\");\\n                        File.copyFile(path, topath);\\n                        if (fileExist(\\\"file://\\\" + topathCache)) {\\n                            File.deleteFiles(topathCache);\\n                        }\\n                        refreshPage(false);\\n                        toast(\\\"导入成功\\\");\\n                        return;\\n                    }\\n                });\\n            } else {\\n                let requireUrl = \\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\";\\n                let fileSelect = $.require(requireUrl);\\n                return fileSelect.fileSelectionUri({\\n                    callback: $.toString(() => {\\n                        const Config = $.require(\\\"hiker://page/Config.js\\\");\\n                        let fileMatch = PATH.match(/\\\\/([^\\\\/]*?)(\\\\.txt|\\\\.epub)$/i);\\n                        let novelName = fileMatch[1];\\n                        let topath = Config.externalImportPath + novelName + fileMatch[2];\\n                        let topathCache = Config.contentsCache + novelName + fileMatch[2];\\n                        let path = PATH;\\n                        if (fileExist(\\\"file://\\\" + topath)) {\\n                            return $(\\\"已存在[\\\" + novelName + \\\"]是否覆盖?\\\").confirm((path, topath, topathCache) => {\\n                                const File = $.require(\\\"hiker://page/File.js\\\");\\n                                File.copyFile(path, topath, true);\\n                                if (fileExist(\\\"file://\\\" + topathCache)) {\\n                                    File.deleteFiles(topathCache);\\n                                }\\n                                back();\\n                                return \\\"toast://导入成功\\\";\\n                            }, path, topath, topathCache);\\n                        } else {\\n                            const File = $.require(\\\"hiker://page/File.js\\\");\\n                            File.copyFile(path, topath);\\n                            if (fileExist(\\\"file://\\\" + topathCache)) {\\n                                File.deleteFiles(topathCache);\\n                            }\\n                            back();\\n                            return \\\"toast://导入成功\\\";\\n                        }\\n                    }),\\n                    fileType: \\\".txt|.epub\\\",\\n                    onClickType: \\\"confirm\\\",\\n                    store: \\\"selectPathCache1\\\",\\n                    memoryPath: true\\n                });\\n            }\\n        }),\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n    let options = [\\\"阅读\\\", \\\"分享\\\", \\\"删除\\\", \\\"打开方式\\\"];\\n\\n    let pattern = getMyVar(\\\":txtPattern\\\", options[0]);\\n    let id = Date.now() + \\\":模式\\\";\\n    layout.push({\\n        title: pattern,\\n        col_type: \\\"text_3\\\",\\n        url: $(options, 1, \\\"操作模式\\\").select((id) => {\\n            putMyVar(\\\":txtPattern\\\", input);\\n            updateItem(id, {\\n                title: input\\n            });\\n        }, id),\\n        extra: {\\n            id: id\\n        }\\n    });\\n    layout.push({\\n        title: \\\"文件管理\\\",\\n        col_type: \\\"text_3\\\",\\n        url: \\\"hiker://page/FileManagement.view#noRefresh##noRecordHistory##noHistory#?type=externalImportPath\\\"\\n    });\\n    layout.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n\\n    function operation(path, name, type) {\\n        let pattern = getMyVar(\\\":txtPattern\\\", \\\"阅读\\\");\\n        switch (pattern) {\\n            case \\\"分享\\\":\\n                return \\\"share://\\\" + path;\\n                break;\\n            case \\\"删除\\\":\\n                return $(\\\"确认删除[\\\" + name + \\\"]\\\").confirm((path) => {\\n                    const File = $.require(\\\"hiker://page/File.js\\\");\\n                    if (File.deleteFiles(path)) {\\n                        if (fileExist(\\\"file://\\\" + path + \\\".json\\\")) {\\n                            File.deleteFiles(path + \\\".json\\\");\\n                        }\\n                        //refreshPage();\\n                        deleteItem(path)\\n                        return \\\"toast://删除成功\\\";\\n                    } else {\\n                        return \\\"toast://删除失败\\\";\\n                    }\\n                }, path);\\n                break;\\n            case \\\"阅读\\\":\\n                return (type===\\\".txt\\\"?\\\"hiker://page/txtParser.view\\\":\\\"hiker://page/epubParser.view#autoCache#\\\")+\\\"?rule=\\\" + MY_RULE.title;\\n                break;\\n            case \\\"打开方式\\\":\\n                return \\\"openFile://file://\\\" + path;\\n                break;\\n        }\\n    }\\n\\n    for (let novel of files) {\\n        let type = novel.name.substring(novel.name.lastIndexOf(\\\".\\\"));\\n        layout.push({\\n            title: novel.name,\\n            url: $(\\\"#noLoading#\\\").lazyRule(operation, novel.path, novel.name, type),\\n            desc: \\\"大小：\\\" + File.getFileSize(novel.path) + \\\"\\\\n修改时间：\\\" + $.dateFormat(novel.lastModified, \\\"yyyy-MM-dd HH:mm:ss\\\"),\\n            col_type: \\\"text_1\\\",\\n            extra: {\\n                path: novel.path,\\n                isCache: true,\\n                title: novel.name,\\n                id: novel.path,\\n                longClick: [{\\n                    title: \\\"分享\\\",\\n                    js: JSON.stringify(\\\"share://\\\" + novel.path)\\n                }, {\\n                    title: \\\"阅读\\\",\\n                    js: JSON.stringify((type===\\\".txt\\\"?\\\"hiker://page/txtParser.view\\\":\\\"hiker://page/epubParser.view#autoCache#\\\")+\\\"?rule=\\\" + MY_RULE.title)\\n                }, {\\n                    title: \\\"打开方式\\\",\\n                    js: JSON.stringify(\\\"openFile://file://\\\" + novel.path)\\n                }, {\\n                    title: \\\"删除\\\",\\n                    js: $.toString((path) => {\\n                        return $.require(\\\"longPress.js\\\").deleteFileForTxt(path)\\n                    }, novel.path)\\n                }]\\n            }\\n        });\\n    }\\n    if (files.length === 0) {\\n        layout.push({\\n            title: \\\"设置\\\",\\n            url: \\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\",\\n            col_type: \\\"text_2\\\",\\n            extra: {\\n                version: MY_RULE.version\\n            }\\n        });\\n\\n        layout.push({\\n            title: \\\"““帮助””\\\",\\n            url: \\\"hiker://page/help.view#noRefresh##noRecordHistory##noHistory#?keyword=txt\\\",\\n            col_type: \\\"text_2\\\"\\n        });\\n        layout.push({\\n            title: '<h1 style=\\\"text-align: center;\\\">啥都没有耶</h1>',\\n            col_type: \\\"rich_text\\\"\\n        });\\n    }\\n    setResult(layout);\\n}\\n\\nif ($.importParam === undefined) {\\n    $.exports = txtView;\\n} else if ($.importParam === null) {\\n    setResult(txtView([]));\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#v.TXT解析器\",\"path\":\"txtParser.view\",\"rule\":\"js:\\n(function() {\\n    const Config = $.require(\\\"Config.js\\\");\\n    let regs = $.require(\\\"hiker://page/regularChapter.f\\\");\\n    let path = decodeURIComponent(getParam(\\\"path\\\") || \\\"\\\") || MY_PARAMS.path;\\n    let charst = decodeURIComponent(getParam(\\\"charst\\\") || \\\"\\\") || MY_PARAMS.charst || \\\"UTF-8\\\";\\n    let isCache = decodeURIComponent(getParam(\\\"isCache\\\") || \\\"\\\") || MY_PARAMS.isCache;\\n    if (!path.startsWith(\\\"file://\\\")) {\\n        path = \\\"file://\\\" + path;\\n    }\\n    if(MY_PARAMS.title){\\n        setPageTitle(MY_PARAMS.title);\\n    }else{\\n        setPageTitle($.require(\\\"hiker://page/File.js\\\").getName(path));\\n    }\\n    let layout = [];\\n    let chapterNames = [];\\n    let intervals = [];\\n    let hasPreface = false;\\n    let cachePath = path.replace(Config.externalImportPath, Config.contentsCache);\\n    if (isCache&&fileExist(cachePath)) {\\n        try {\\n\\n            let c = JSON.parse(request(cachePath));\\n            chapterNames = c.chapterNames;\\n            intervals = c.intervals;\\n            hasPreface = c.hasPreface;\\n            layout.push({\\n                title: \\\"重新解析目录\\\",\\n                col_type: \\\"text_center_1\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((path) => {\\n                    deleteFile(path);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }, path+\\\".json\\\"),\\n                extra: {\\n                    lineVisible:false\\n                }\\n            });\\n            layout.push({\\n                col_type:\\\"line_blank\\\"\\n            });\\n        } catch (e) {\\n            log(e.toString());\\n            setResult([{\\n                title: \\\"““””<strong>目录解析失败(重新解析)</strong>\\\".big(),\\n                col_type: \\\"text_center_1\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((path) => {\\n                    deleteFile(path);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }, path+\\\".json\\\"),\\n                extra: {\\n                    lineVisible: false\\n                }\\n            }]);\\n            return;\\n        }\\n\\n    } else {\\n        showLoading(\\\"正在解析目录\\\");\\n        let txt = request(path, {\\n            headers: {\\n                //\\\"content-type\\\": \\\"text/plain; charst=\\\" + charst\\n            }\\n        });\\n        let pattern = regs.getTocRule(txt);\\n        if (!pattern) {\\n            hideLoading();\\n            setResult([{\\n                title: \\\"““””<strong>目录解析失败</strong>\\\".big(),\\n                col_type: \\\"text_center_1\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n                    back(false);\\n                    return \\\"hiker://empty\\\";\\n                }),\\n                extra: {\\n                    lineVisible: false\\n                }\\n            }]);\\n            return;\\n        }\\n        let matcher = pattern.matcher(txt);\\n        let pointer = 0;\\n        while (matcher.find()) {\\n            let start = matcher.start();\\n            let end = matcher.end();\\n            let t = matcher.group();\\n            if (pointer === 0 && start > 30) {\\n                hasPreface = true;\\n            }\\n            chapterNames.push(t);\\n            intervals.push([pointer, start]);\\n            pointer = end;\\n        }\\n        intervals.push([pointer, txt.length]);\\n        if (isCache) {\\n            writeFile(cachePath, JSON.stringify({\\n                chapterNames: chapterNames,\\n                intervals: intervals,\\n                hasPreface: hasPreface\\n            }));\\n        }\\n        hideLoading();\\n    }\\n\\n\\n    if (hasPreface) {\\n        let interval = intervals[0];\\n        layout.push({\\n            title: \\\"序言\\\",\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/TXTViewer.view#autoPage##readTheme#\\\",\\n            extra: {\\n                chapterName: \\\"序言\\\",\\n                start: interval[0],\\n                end: interval[1],\\n                path: path,\\n                charst: charst\\n            }\\n        });\\n    }\\n    for (let i = 0; i < chapterNames.length; i++) {\\n        let name = chapterNames[i];\\n        let interval = intervals[i + 1];\\n        layout.push({\\n            title: name,\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/TXTViewer.view#autoPage##readTheme#\\\",\\n            extra: {\\n                start: interval[0],\\n                end: interval[1],\\n                chapterName: name,\\n                path: path,\\n                charst: charst\\n            }\\n        });\\n    }\\n    setResult(layout);\\n})()\"},{\"col_type\":\"movie_3\",\"name\":\"#v.TXT查看器\",\"path\":\"TXTViewer.view\",\"rule\":\"js:\\nlet path = MY_PARAMS.path;\\nlet charst = MY_PARAMS.charst;\\nlet txt = request(path, {\\n    headers: {\\n       //\\\"content-type\\\": \\\"text/plain; charst=\\\" + charst\\n    }\\n});\\n\\nlet targetTexts = txt.substring(MY_PARAMS.start, MY_PARAMS.end);\\n\\nlet content = targetTexts.split(/(\\\\n|\\\\r)+/).filter(it => it.length > 1).join(\\\"<br>\\\");\\nlet layout = [];\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + MY_PARAMS.chapterName + \\\"</strong>\\\").big(),\\n});\\n\\nlayout.push({\\n    title: content,\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: 18,\\n        click: true\\n    }\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#j.章节正则\",\"path\":\"regularChapter.f\",\"rule\":\"js:\\nlet rules = [{\\n        \\\"id\\\": -1,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"目录(去空白)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和]))).{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 假装第一章前面有空白但我不要\\\",\\n        \\\"serialNumber\\\": 0\\n    },\\n    {\\n        \\\"id\\\": -2,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"目录\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|篇(?!张))).{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 标准的粤语就是这样\\\",\\n        \\\"serialNumber\\\": 1\\n    },\\n    {\\n        \\\"id\\\": -3,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"目录(匹配简介)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])(?:(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|回(?![合来事去])|场(?![和合比电是])|篇(?!张))).{0,30}$\\\",\\n        \\\"example\\\": \\\"简介 老夫诸葛村夫\\\",\\n        \\\"serialNumber\\\": 2\\n    },\\n    {\\n        \\\"id\\\": -4,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"目录(古典、轻小说备用)\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\s{0,4}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|回(?![合来事去])|场(?![和合比电是])|话|篇(?!张))).{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 比上面只多了回和话\\\",\\n        \\\"serialNumber\\\": 3\\n    },\\n    {\\n        \\\"id\\\": -5,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"数字(纯数字标题)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])\\\\\\\\d+\\\\\\\\.?[ 　\\\\\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"12\\\",\\n        \\\"serialNumber\\\": 4\\n    },\\n    {\\n        \\\"id\\\": -6,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"大写数字(纯数字标题)\\\",\\n        \\\"rule\\\": \\\"(?<=[　\\\\\\\\s])[〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,12}[ 　\\\\\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"一百七十\\\",\\n        \\\"serialNumber\\\": 4\\n    },\\n    {\\n        \\\"id\\\": -7,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"数字 分隔符 标题名称\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}\\\\\\\\d{1,5}[:：,.， 、_—\\\\\\\\-].{1,30}$\\\",\\n        \\\"example\\\": \\\"1、这个就是标题\\\",\\n        \\\"serialNumber\\\": 5\\n    },\\n    {\\n        \\\"id\\\": -8,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"大写数字 分隔符 标题名称\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|[〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8})[ 、_—\\\\\\\\-].{1,30}$\\\",\\n        \\\"example\\\": \\\"一、只有前面的数字有差别\\\",\\n        \\\"serialNumber\\\": 6\\n    },\\n    {\\n        \\\"id\\\": -9,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"正文 标题/序号\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}正文[ 　]{1,4}.{0,20}$\\\",\\n        \\\"example\\\": \\\"正文 我奶常山赵子龙\\\",\\n        \\\"serialNumber\\\": 7\\n    },\\n    {\\n        \\\"id\\\": -10,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"Chapter/Section/Part/Episode 序号 标题\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:[Cc]hapter|[Ss]ection|[Pp]art|ＰＡＲＴ|[Nn][oO]\\\\\\\\.|[Ee]pisode|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)\\\\\\\\s{0,4}\\\\\\\\d{1,4}.{0,30}$\\\",\\n        \\\"example\\\": \\\"Chapter 1 MyGrandmaIsNB\\\",\\n        \\\"serialNumber\\\": 8\\n    },\\n    {\\n        \\\"id\\\": -11,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"Chapter(去简介)\\\",\\n        \\\"rule\\\": \\\"^[ 　\\\\\\\\t]{0,4}(?:[Cc]hapter|[Ss]ection|[Pp]art|ＰＡＲＴ|[Nn][Oo]\\\\\\\\.|[Ee]pisode)\\\\\\\\s{0,4}\\\\\\\\d{1,4}.{0,30}$\\\",\\n        \\\"example\\\": \\\"Chapter 1 MyGrandmaIsNB\\\",\\n        \\\"serialNumber\\\": 9\\n    },\\n    {\\n        \\\"id\\\": -12,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"特殊符号 序号 标题\\\",\\n        \\\"rule\\\": \\\"(?<=[\\\\\\\\s　])[【〔〖「『〈［\\\\\\\\[](?:第|[Cc]hapter)[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,10}[章节].{0,20}$\\\",\\n        \\\"example\\\": \\\"【第一章 后面的符号可以没有\\\",\\n        \\\"serialNumber\\\": 10\\n    },\\n    {\\n        \\\"id\\\": -13,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"特殊符号 标题(成对)\\\",\\n        \\\"rule\\\": \\\"(?<=[\\\\\\\\s　]{0,4})(?:[\\\\\\\\[〈「『〖〔《（【\\\\\\\\(].{1,30}[\\\\\\\\)】）》〕〗』」〉\\\\\\\\]]?|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)[ 　]{0,4}$\\\",\\n        \\\"example\\\": \\\"『加个直角引号更专业』\\\",\\n        \\\"serialNumber\\\": 11\\n    },\\n    {\\n        \\\"id\\\": -14,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"特殊符号 标题(单个)\\\",\\n        \\\"rule\\\": \\\"(?<=[\\\\\\\\s　]{0,4})(?:[☆★✦✧].{1,30}|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)[ 　]{0,4}$\\\",\\n        \\\"example\\\": \\\"☆、晋江作者最喜欢的格式\\\",\\n        \\\"serialNumber\\\": 12\\n    },\\n    {\\n        \\\"id\\\": -15,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"章/卷 序号 标题\\\",\\n        \\\"rule\\\": \\\"^[ \\\\\\\\t　]{0,4}(?:(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|[卷章][\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8})[ 　]{0,4}.{0,30}$\\\",\\n        \\\"example\\\": \\\"卷五 开源盛世\\\",\\n        \\\"serialNumber\\\": 13\\n    },\\n    {\\n        \\\"id\\\": -16,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"顶格标题\\\",\\n        \\\"rule\\\": \\\"^\\\\\\\\S.{1,20}$\\\",\\n        \\\"example\\\": \\\"不超过20个字顶格写的都是标题\\\",\\n        \\\"serialNumber\\\": 14\\n    },\\n    {\\n        \\\"id\\\": -17,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"双标题(前向)\\\",\\n        \\\"rule\\\": \\\"(?m)(?<=[ \\\\\\\\t　]{0,4})第[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$(?=[\\\\\\\\s　]{0,8}第[\\\\\\\\d零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章)\\\",\\n        \\\"example\\\": \\\"第一章 真正的标题并假装换行第一章 这个不要\\\",\\n        \\\"serialNumber\\\": 15\\n    },\\n    {\\n        \\\"id\\\": -18,\\n        \\\"enable\\\": false,\\n        \\\"name\\\": \\\"双标题(后向)\\\",\\n        \\\"rule\\\": \\\"(?m)(?<=[ \\\\\\\\t　]{0,4}第[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$[\\\\\\\\s　]{0,8})第[\\\\\\\\d零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$\\\",\\n        \\\"example\\\": \\\"第一章 这个标题不要并假装换行第一章真正的标题\\\",\\n        \\\"serialNumber\\\": 16\\n    },\\n    {\\n        \\\"id\\\": -19,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"书名 括号 序号\\\",\\n        \\\"rule\\\": \\\"^.{1,20}[(（][\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}[)）][ 　\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"标题后面数字有括号(12)\\\",\\n        \\\"serialNumber\\\": 17\\n    },\\n    {\\n        \\\"id\\\": -20,\\n        \\\"enable\\\": true,\\n        \\\"name\\\": \\\"书名 序号\\\",\\n        \\\"rule\\\": \\\"^.{1,20}[\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}[ 　\\\\t]{0,4}$\\\",\\n        \\\"example\\\": \\\"标题后面数字没有括号124\\\",\\n        \\\"serialNumber\\\": 18\\n    }\\n];\\nlet Matcher = java.util.regex.Matcher;\\nlet Pattern = java.util.regex.Pattern;\\n\\nfunction getTocRule(content) {\\n    let maxCs = 1;\\n    let tocPattern = null;\\n    for (let tocRule of rules) {\\n        if (!tocRule.enable) continue;\\n        let pattern = Pattern.compile(tocRule.rule, Pattern.MULTILINE);\\n        let matcher = pattern.matcher(content);\\n        let cs = 0;\\n        while (matcher.find()) {\\n            cs++;\\n        }\\n        if (cs >= maxCs) {\\n            maxCs = cs;\\n            tocPattern = pattern;\\n        }\\n    }\\n    return tocPattern;\\n}\\n$.exports.getTocRule = getTocRule;\"},{\"col_type\":\"movie_3\",\"name\":\"#V.帮助\",\"path\":\"help.view\",\"rule\":\"js:\\nlet helpText = {\\n    \\\"txt\\\": `\\n        <h1 id=\\\"txt是什么\\\">TXT是什么?</h1>\\n        <p><a href=\\\"https://baike.baidu.com/item/txt/1217330\\\">我已经帮你百度了</a>；简单来说就是一种储存小说的文件(扩展名:txt)。</p>\\n        <h1 id=\\\"如何用该小程序阅读txt小说\\\">如何用该小程序阅读txt小说?</h1>\\n        <p>在主页面 ◉TXT 界面下，点击导入TXT，选择目标小说文件(txt文件，<em>该操作不会删除txt文件，而是copy一份到小程序的路径下</em>)，导入后再在 ◉TXT 界面下选择想要阅读的小说即可。</p>\\n\\n    `,\\n    \\\"novelComic\\\": `\\n        <h1 id=\\\"这个小程序有什么用？\\\">这个小程序有什么用？</h1>\\n        <ul>\\n        <li><u>代码上为其他小程序(漫画类/小说类)提供下载接口。</u></li>\\n        <li><u>本体充当阅读器，可以浏览用该小程序提供的下载接口(上面)，下载的漫画/小说。</u></li>\\n        <li><u>提供TXT格式小说文件解析功能。</u>\\n        <h1 id=\\\"为什么列表里什么都没用\\\">为什么列表里什么都没用?</h1>\\n        <u>初次使用，没有很正常吧。🤔</u>\\n        <h1 id=\\\"该如何添加漫画或小说\\\">该如何添加漫画(或小说)?</h1>\\n        <u> 在一个有下载功能的小程序(漫画类/小说类)中下载一本漫画/小说，返回该规则即可浏览。</u></li>\\n        </ul>\\n    `\\n};\\nsetPageTitle(\\\"帮助\\\");\\nlet keyword = getParam(\\\"keyword\\\");\\nlet text;\\nif (keyword === undefined || !(text = helpText[keyword])) {\\n    setResult([{\\n        title: '<h1 style=\\\"text-align: center;\\\">资料不见咯</h1>',\\n        col_type: \\\"rich_text\\\"\\n    }]);\\n} else {\\n    setResult([{\\n        title: text,\\n        col_type: \\\"rich_text\\\"\\n    }]);\\n}\"},{\"col_type\":\"text_1\",\"name\":\"#v.外导搜索\",\"path\":\"txtSearch.view\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.js\\\");\\n\\nlet searchTerms = decodeURIComponent(getParam(\\\"searchTerms\\\"));\\nsetPageTitle(\\\"「\\\" + searchTerms + \\\"」的搜索结果\\\");\\nlet data = File.getFilePath(Config.externalImportPath, undefined);\\ndata = data.filter(v => /(\\\\.txt|\\\\.epub)$/.test(v.name));\\n\\nlet termsArr = searchTerms.split(\\\"\\\").map(t => t.replace(/\\\\*|\\\\.|\\\\?|\\\\+|\\\\$|\\\\^|\\\\[|\\\\]|\\\\(|\\\\)|\\\\{|\\\\}|\\\\||\\\\/|\\\\\\\\/g, k => \\\"\\\\\\\\\\\" + k));\\nlet reg = new RegExp(termsArr.join(\\\".*\\\"), \\\"i\\\");\\nlet searchResult = [];\\nfor (let txt of data) {\\n    if (reg.test(txt.name)) {\\n        let type = txt.name.substring(txt.name.lastIndexOf(\\\".\\\"));\\n        searchResult.push({\\n            title: txt.name,\\n            url: (type===\\\".txt\\\"?\\\"hiker://page/txtParser.view\\\":\\\"hiker://page/epubParser.view#autoCache#\\\")+\\\"?rule=\\\" + MY_RULE.title,\\n            desc: txt.path,\\n            extra: {\\n                path: txt.path,\\n                isCache: true,\\n                title: txt.name\\n            }\\n        });\\n    }\\n}\\nif (searchResult.length === 0) {\\n    searchResult.push({\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        col_type: \\\"big_big_blank_block\\\",\\n    }, {\\n        title: '<h2 style=\\\"text-align: center;\\\">🔎没有找到相关书籍</h2>',\\n        col_type: \\\"rich_text\\\"\\n    });\\n}\\nsetResult(searchResult);\"},{\"col_type\":\"movie_3\",\"name\":\"#f.长按/点击\",\"path\":\"longPress.js\",\"rule\":\"js:\\n$.exports = {\\n    deleteFileForBook(path) {\\n        //return $(\\\"所有的 漫画/小说 章节将被删除\\\\m确认删除？\\\").confirm((path) => {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFiles(path)) {\\n            deleteItem(path)\\n            return \\\"toast://删除成功\\\";\\n        } else {\\n            return \\\"toast://删除失败\\\";\\n        }\\n        //}, path);\\n    },\\n    deleteFileForTxt(path) {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        if (File.deleteFiles(path)) {\\n            if (fileExist(\\\"file://\\\" + path + \\\".json\\\")) {\\n                File.deleteFiles(path + \\\".json\\\");\\n            }\\n            deleteItem(path);\\n            return \\\"toast://删除成功\\\";\\n        } else {\\n            return \\\"toast://删除失败\\\";\\n        }\\n    },\\n    singleEnter(pageUrl, path) {\\n        const File = $.require(\\\"hiker://page/File.js\\\");\\n        let dirs = File.getFilePath(path, \\\"dir\\\");\\n        if (dirs.length === 1) {\\n            const Config = $.require(\\\"hiker://page/Config.js\\\");\\n            let fi = dirs[0].path;\\n            if (Config.def_isComicCompatible === \\\"0\\\") {\\n                let filelist = File.getFilePath(fi);\\n                let shorten = fi.replace(getPath(\\\"hiker://files/\\\").slice(7), \\\"hiker://files/\\\");\\n                let piclist = filelist.map((item, i) => shorten + \\\"/\\\" + (i + 1) + \\\".jpg\\\");\\n                return \\\"pics://\\\" + piclist.join(\\\"&&\\\");\\n\\n            } else {\\n                return \\\"hiker://page/comicCompatible.view#autoPage##readTheme#?path=\\\" + encodeURIComponent(fi);\\n            }\\n        } else {\\n            return pageUrl + \\\"?rule=\\\" + MY_RULE.title\\n        }\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#fg.下载主程序\",\"path\":\"mainDownload\",\"rule\":\"const File = $.require(\\\"hiker://page/File.js\\\");\\nconst Config = $.require(\\\"hiker://page/Config.js\\\");\\nconst Tool = $.require(\\\"hiker://page/Tool.js\\\");\\n\\n\\n$.exports.novel = function novel(item, info, order, MY_ID, interrupt) {\\n    let id = info.bookId ? \\\"$\\\" + info.bookId : \\\"\\\";\\n    let mainPath = Config.novelPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + Tool.textShield(info.bookName) + id + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$A$\\\" + Tool.textShield(item.title) + \\\".txt\\\";\\n    let content = \\\"\\\";\\n    if (interrupt && getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n        return -1;\\n    }\\n    try {\\n        let setResult = data => {\\n            content = data[0].title || \\\"\\\";\\n            if (data.length > 1 && data[1].title && data[1].title.length > content.length) {\\n                content = data[1].title;\\n            }\\n        }\\n        let getResCode = () => {\\n            return fetch(item.url);\\n        }\\n        let getContent = new Function(\\\"input\\\", \\\"url\\\", \\\"index\\\", \\\"title\\\", \\\"setResult\\\", \\\"getResCode\\\", \\\"return \\\" + info.parseCode);\\n        content = getContent(item.url, item.url, order, item.title, setResult, getResCode) || content || \\\"\\\";\\n    } catch (e) {\\n        e.message = \\\"<小说正文解析错误> \\\" + e.message;\\n        throw e;\\n    }\\n    if (!content) {\\n        toast(\\\"小说为空\\\");\\n        throw new Error(\\\"<小说正文解析错误：正文返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + id + \\\".jpg\\\", bookTopPic[1], info.decode);\\n\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\/script>/gmi, \\\"\\\").trimRight());\\n    //File.renameFile(chapterPath, order + \\\"$A$\\\" + item.title + \\\".txt\\\");\\n}\\n\\n$.exports.comic = function comic(item, info, order, MY_ID, interrupt) {\\n    let id = info.bookId ? \\\"$\\\" + info.bookId : \\\"\\\";\\n    let mainPath = Config.comicPath + \\\"/\\\" + info.ruleName + \\\"/\\\" + Tool.textShield(info.bookName) + id + \\\"/\\\";\\n    let chapterPath = mainPath + order + \\\"$B$\\\" + Tool.textShield(item.title) + \\\"/\\\";\\n    let picList = [];\\n    try {\\n        let getPicList = new Function(\\\"input\\\", \\\"url\\\", \\\"index\\\", \\\"title\\\", \\\"return\\\" + info.parseCode);\\n        picList = getPicList(item.url, item.url, order, item.title);\\n        if (typeof picList === \\\"string\\\") {\\n            picList = picList.replace(\\\"pics://\\\", \\\"\\\").split(\\\"&&\\\");\\n        }\\n    } catch (e) {\\n        e.message = \\\"<漫画图片解析错误> \\\" + e.message;\\n        throw e;\\n    }\\n    picList = picList.filter(p => p);\\n    const L = picList.length;\\n    if (L === 0) {\\n        toast(\\\"图片链接为空\\\");\\n        throw new Error(\\\"<漫画图片解析错误：图片链接返回为空>\\\");\\n    }\\n    if (info.bookTopPic) {\\n        try {\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\n            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + id + \\\".jpg\\\", bookTopPic[1], info.decode);\\n        } catch (e) {\\n            log(\\\"<封面下载错误> \\\" + e.message);\\n        }\\n    }\\n\\n    let errorNum = 0;\\n    for (var i = 0; i < L; i++) {\\n        try {\\n            let pic = Tool.hikerPic(picList[i]);\\n            Tool.picDownload(pic[0], chapterPath + (i + 1) + \\\".jpg\\\", pic[1], info.decode);\\n            if (interrupt && getMyVar(MY_ID + \\\":status\\\", \\\"\\\") === \\\"1\\\") {\\n                return -1;\\n            }\\n            errorNum = 0;\\n        } catch (e) {\\n            if (errorNum < 10) {\\n                i--;\\n                errorNum++;\\n                continue;\\n            } else {\\n                throw e;\\n            }\\n        }\\n    }\\n\\n    File.renameFile(chapterPath, order + \\\"$A$\\\" + Tool.textShield(item.title));\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#v.漫画兼容\",\"path\":\"comicCompatible.view\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js\\\");\\nsetPageTitle(MY_PARAMS.title);\\nlet path=decodeURIComponent(getParam(\\\"path\\\",MY_PARAMS.path));\\nlet filelist = File.getFilePath(path);\\nlet piclist = filelist.map((item, i) => ({\\n    col_type: \\\"pic_1_full\\\",\\n    url: \\\"hiker://empty\\\",\\n    pic_url: path + \\\"/\\\" + (i + 1) + \\\".jpg\\\"\\n}));\\n\\nsetResult(piclist);\\n\"},{\"col_type\":\"movie_3\",\"name\":\"#v.书架\",\"path\":\"Bookrack.view\",\"rule\":\"js:\\nconst File = $.require(\\\"File.js\\\");\\nconst rank = $.require(\\\"fileRank.js\\\");\\nconst Tool = $.require(\\\"Tool.js\\\");\\nconst Config = $.require(\\\"Config.js\\\");\\n\\n(function() {\\n    let type = MY_PARAMS.type || getParam(\\\"type\\\", \\\"\\\") || \\\"comic\\\";\\n    let ruleName = Tool.textShield(MY_PARAMS.ruleName || decodeURIComponent(getParam(\\\"ruleName\\\")));\\n    if (!ruleName) {\\n        toast(\\\"请传入规则名\\\");\\n        back(false);\\n    }\\n    if (![\\\"comic\\\", \\\"novel\\\"].includes(type)) {\\n        toast(\\\"请传入正确的type:comic novel\\\");\\n        back(false);\\n    }\\n    setPageTitle(ruleName + \\\"|本地书架\\\");\\n    let layout = [];\\n    let path = Config[type + \\\"Path\\\"] + ruleName;\\n    let col_type = getItem(\\\"bookrack:col_type\\\", \\\"movie_3_marquee\\\");\\n    let rankMethod = getItem(\\\"bookrack:rankMethod\\\", \\\"系统\\\");\\n    let rankIsReverse = getItem(\\\"bookrack:rankIsReverse\\\", \\\"\\\");\\n\\n    let colTypes = [\\\"movie_1\\\", \\\"movie_2\\\", \\\"movie_3_marquee\\\", \\\"movie_1_vertical_pic\\\", \\\"pic_2\\\", \\\"pic_3\\\", \\\"pic_3_square\\\", \\\"pic_2_card\\\"];\\n    \\n    let rankMethods = [\\\"系统\\\", \\\"大小\\\", \\\"名称\\\", \\\"时间\\\"];\\n    layout.push({\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        desc: \\\"搜你想要的#\\\" + type + \\\"#......\\\",\\n        title: \\\"🔍\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            rules: $.toString((ruleName, type) => {\\n                let arr1 = [{\\n                        \\\"title\\\": ruleName,\\n                        \\\"search_url\\\": \\\"hiker://empty?isAll=1&searchTerms=**&type=\\\" + type,\\n                        \\\"searchFind\\\": \\\"js:$.require('hiker://page/Search.view?rule='+MY_RULE._title);\\\"\\n                    }];\\n                \\n                return JSON.stringify(arr1);\\n            }, ruleName, type),\\n            /*defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"*/\\n        }\\n    });\\n\\n    layout.push({\\n        title: \\\"🧩\\\",\\n        col_type: \\\"flex_button\\\",\\n        url: $(colTypes.map(v=>v===col_type?\\\"““\\\"+v+\\\"””\\\":v)).select((name) => {\\n            if(/““.*?””/.test(input)) return;\\n            setItem(\\\"bookrack:col_type\\\", input);\\n            refreshPage();\\n        })\\n    });\\n    for (let name of rankMethods) {\\n        let a = rankMethod === name;\\n        let titlea = a ? \\\"‘‘\\\" + name + \\\"’’\\\" : name;\\n        let titleb = \\\"\\\";\\n        if (a) {\\n            titleb = !rankIsReverse ? \\\"↓\\\" : \\\"↑\\\";\\n        } else {\\n            titleb = \\\"↕\\\";\\n        }\\n        layout.push({\\n            title: titlea + titleb,\\n            col_type: \\\"flex_button\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule((name) => {\\n                let rankMethod = getItem(\\\"bookrack:rankMethod\\\", \\\"系统\\\");\\n                let rankIsReverse = getItem(\\\"bookrack:rankIsReverse\\\", \\\"\\\");\\n\\n                if (rankMethod === name) {\\n                    if (rankIsReverse) {\\n                        rankIsReverse = \\\"\\\";\\n                    } else {\\n                        rankIsReverse = \\\"1\\\";\\n                    }\\n\\n                    setItem(\\\"bookrack:rankIsReverse\\\", rankIsReverse);\\n                } else {\\n                    setItem(\\\"bookrack:rankIsReverse\\\", \\\"\\\");\\n                    setItem(\\\"bookrack:rankMethod\\\", name);\\n\\n                }\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\";\\n            }, name)\\n        });\\n    }\\n    let rankMethodMap = {\\n        \\\"系统\\\": \\\"\\\",\\n        \\\"大小\\\": \\\"size\\\",\\n        \\\"名称\\\": \\\"name\\\",\\n        \\\"时间\\\": \\\"time\\\"\\n    };\\n    let bookList = [];\\n    let list = rank(File.getFiles(path, \\\"dir\\\"), rankMethodMap[rankMethod]);\\n    if (list.length === 0) {\\n        bookList.push({\\n            title: \\\"““””\\\" + \\\"啥都没有耶\\\".big(),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n\\n    }\\n    let pageUrl = type === \\\"novel\\\" ? \\\"hiker://page/NovelBrowser.view\\\" : \\\"hiker://page/ComicBrowser.view\\\";\\n    for (let item of list) {\\n        let pic = fileExist(\\\"file://\\\" + item.getPath() + \\\"/\\\" + item.getName() + \\\".jpg\\\") ? item.getPath() + \\\"/\\\" + item.getName() + \\\".jpg\\\" : Config.def_Pic;\\n        let names=String(item.getName()).split(\\\"$\\\");\\n        bookList.push({\\n            title: names[0],\\n            desc: names[1],\\n            pic_url: pic,\\n            url: type === \\\"novel\\\" ?pageUrl + \\\"?rule=\\\" + MY_RULE.title:$(\\\"#noLoading#\\\").lazyRule((pageUrl, path)=>{\\n                return $.require(\\\"longPress.js\\\").singleEnter(pageUrl, path);\\n            }, pageUrl, item.getPath()),\\n            col_type:col_type,\\n            extra: {\\n                longClick: [{\\n                    title: \\\"删除\\\",\\n                    js: $.toString((path) => {\\n                        return $.require(\\\"longPress.js\\\").deleteFileForBook(path);\\n                    }, item.getPath())\\n                }],\\n                id: item.getPath(),\\n                path: item.getPath(),\\n                name: item.getName()\\n            }\\n        });\\n    }\\n    if (rankIsReverse) {\\n        bookList.reverse();\\n    }\\n\\n    setResult(layout.concat(bookList));\\n})();\"},{\"col_type\":\"movie_3\",\"name\":\"#f.文件排序\",\"path\":\"fileRank.js\",\"rule\":\"js:\\nconst File = $.require(\\\"File.js\\\");\\nlet chnNumChar = {\\n    零: 0,\\n    一: 1,\\n    二: 2,\\n    三: 3,\\n    四: 4,\\n    五: 5,\\n    六: 6,\\n    七: 7,\\n    八: 8,\\n    九: 9\\n};\\n\\nlet chnNameValue = {\\n    十: {\\n        value: 10,\\n        secUnit: false\\n    },\\n    百: {\\n        value: 100,\\n        secUnit: false\\n    },\\n    千: {\\n        value: 1000,\\n        secUnit: false\\n    },\\n    万: {\\n        value: 10000,\\n        secUnit: true\\n    },\\n    亿: {\\n        value: 100000000,\\n        secUnit: true\\n    }\\n}\\n\\nfunction ChineseToNumber(chnStr) {\\n    let rtn = 0;\\n    let section = 0;\\n    let number = 0;\\n    let secUnit = false;\\n    let str = chnStr.split('');\\n\\n    for (let i = 0; i < str.length; i++) {\\n        let num = chnNumChar[str[i]];\\n        if (typeof num !== 'undefined') {\\n            number = num;\\n            if (i === str.length - 1) {\\n                section += number;\\n            }\\n        } else {\\n            let unit = chnNameValue[str[i]].value;\\n            secUnit = chnNameValue[str[i]].secUnit;\\n            if (secUnit) {\\n                section = (section + number) * unit;\\n                rtn += section;\\n                section = 0;\\n            } else {\\n                section += (number * unit);\\n            }\\n            number = 0;\\n        }\\n    }\\n    return rtn + section;\\n}\\n\\nfunction nameCompare(a, b) {\\n    if (a == null || b == null)\\n        return a == null ? b == null ? 0 : -1 : 1;\\n\\n    a = a.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return ChineseToNumber(p1);\\n    })\\n    b = b.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return ChineseToNumber(p1);\\n    })\\n\\n    let NUMBERS = java.util.regex.Pattern.compile(\\\"(?<=\\\\\\\\D)(?=\\\\\\\\d)|(?<=\\\\\\\\d)(?=\\\\\\\\D)\\\");\\n    let split1 = NUMBERS.split(new java.lang.String(a));\\n    let split2 = NUMBERS.split(new java.lang.String(b));\\n\\n    for (let i = 0; i < Math.min(split1.length, split2.length); i++) {\\n        let c1 = split1[i].charCodeAt(0);\\n        let c2 = split2[i].charCodeAt(0);\\n        let cmp = 0;\\n        let zeroCharCode = '0'.charCodeAt(0);\\n        let nineCharCode = '9'.charCodeAt(0);\\n\\n        if (c1 >= zeroCharCode && c1 <= nineCharCode && c2 >= zeroCharCode && c2 <= nineCharCode) {\\n            cmp = new java.math.BigInteger(split1[i]).compareTo(new java.math.BigInteger(split2[i]));\\n        }\\n\\n        if (cmp === 0) {\\n            let regex = /[a-zA-Z0-9]/\\n            let s1 = String(split1[i])\\n            let s2 = String(split2[i])\\n            if (regex.test(s1) || regex.test(s2)) {\\n                cmp = new java.lang.String(split1[i]).compareTo(new java.lang.String(split2[i]));\\n                // cmp = s1.localeCompare(s2, 'en')\\n            } else {\\n                cmp = s1.localeCompare(s2, 'zh')\\n            }\\n        }\\n\\n        if (cmp !== 0) {\\n            return cmp;\\n        }\\n    }\\n    let lengthCmp = split1.length - split2.length;\\n    // if (lengthCmp !== 0) lengthCmp = lengthCmp > 0 ? -1 : 1;\\n    return lengthCmp;\\n}\\n\\nfunction rank(list, m) {\\n    switch (m) {\\n        case \\\"type\\\":\\n            return list;\\n        case \\\"name\\\":\\n            return list.sort((a, b) => nameCompare(String(a.getName()), String(b.getName())));\\n        case \\\"size\\\":\\n            return list.sort((a, b) => File.getTotalSizeOfFilesInDir(a) - File.getTotalSizeOfFilesInDir(b));\\n        case \\\"time\\\":\\n            return list.sort((a, b) => a.lastModified() - b.lastModified());\\n        default:\\n            return list;\\n    }\\n\\n}\\n$.exports=rank;\"},{\"col_type\":\"movie_3\",\"name\":\"#v.epub解析器\",\"path\":\"epubParser.view\",\"rule\":\"js:\\nvar layout = [];\\nsetPageTitle(\\\"书籍信息\\\");\\nlet path = decodeURIComponent(getParam(\\\"path\\\") || \\\"\\\") || MY_PARAMS.path;\\nlet meta = getEpubMetadata(path);\\n//log(meta)\\n\\nlayout.push({\\n    title: meta.firstTitle,\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nlayout.push({\\n    title: \\\"👤作者：\\\" + meta.authors[0].lastname,\\n    col_type: \\\"rich_text\\\",\\n});\\nlet description = (meta.descriptions[0] || \\\"\\\").replace(/<p.*?>|<\\\\/p>/g, \\\"\\\");\\nlet tdescription = description;\\nif (description) {\\n    \\n    if (description.length > 50) {\\n        description = description.substring(0, 50) +\\\"......\\\" +\\\"更多>\\\".link($().b64(\\\"'\\\").rule(() => {\\n            setPageTitle(\\\"简介\\\");\\n            setResult([{\\n                title: \\\"简介：<br>　　\\\" + MY_PARAMS.text,\\n                col_type: \\\"rich_text\\\",\\n\\n            }]);\\n        }));\\n    }\\n    layout.push({\\n        title: \\\"📝简介：<br>　　\\\"+description,\\n        col_type: \\\"rich_text\\\",\\n        extra: {\\n            text: tdescription\\n        }\\n    });\\n}\\n//setPageTitle(meta.firstTitle);\\nlayout.push({\\n    col_type: \\\"line_blank\\\",\\n    url: \\\"hiker://empty\\\"\\n});\\nlet chapters = getEpubChapters(path);\\nfor (let it of chapters) {\\n    layout.push({\\n        title: it.title,\\n        url: \\\"hiker://page/epubViewer.view#readTheme##autoPage#\\\",\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            href: it.url,\\n            path: path,\\n            title: it.title\\n        }\\n    });\\n}\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v.epub查看器\",\"path\":\"epubViewer.view\",\"rule\":\"js:\\nlet path = MY_PARAMS.path;\\nlet url = MY_PARAMS.href;\\nlet c = getEpubContent(path, url);\\n//let a= c.replace(/\\\\s?<div.*?>|<\\\\/div>\\\\s?/g, \\\"\\\").replace(/\\\\s?<p.*?>(.*)<\\\\/p>\\\\s?/g, \\\"\\\\u3000\\\\u3000$1<br>\\\");\\n//let b=c.replace(/\\\\s?<div.*?>|<\\\\/div>\\\\s?/g, \\\"\\\").replace(/\\\\s?<p.*?>(.*?)<\\\\/p>\\\\s?/g, \\\"\\\\u3000\\\\u3000$1<br>\\\");\\n//log(a==b)\\n//log(getEpubContent0(path, url))\\n\\nlet layout = [];\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + MY_PARAMS.title + \\\"</strong>\\\").big(),\\n});\\n\\nlayout.push({\\n    title: c,\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: 18,\\n        click: true\\n    }\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"#v文件管理\",\"path\":\"FileManagement.view\",\"rule\":\"js:\\nconst Config = $.require(\\\"hiker://page/Config.js\\\");\\nlet url = \\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\";\\nlet f = $.require(url);\\nlet type = getParam(\\\"type\\\", \\\"homePath\\\");\\naddListener(\\\"onClose\\\", () => {\\n    refreshPage();\\n});\\nlet hikerPath = \\\"file://\\\" + Config.homePath;\\nif(!fileExist(hikerPath)){\\n    writeFile(hikerPath+\\\"/创建目录.txt\\\",\\\"\\\");\\n    deleteFile(hikerPath+\\\"/创建目录.txt\\\");\\n}\\nf.fileSelection({\\n    callback: $.toString(() => {\\n        //根据文件扩展名，用不同小程序打开\\n        if (\\\".jpg\\\" === TYPE) {\\n            return PATH;\\n        } else if (\\\".txt\\\" === TYPE) {\\n            return \\\"hiker://page/txtParser.view?isCache=true&rule=\\\" + MY_RULE.title + \\\"&path=\\\" + PATH;\\n        } else if (\\\".epub\\\" === TYPE) {\\n            return \\\"hiker://page/epubParser.view#autoCache#?rule=\\\" + MY_RULE.title + \\\"&path=\\\" + PATH;\\n        } else {\\n            return $(\\\"无法打开，是否使用其他应用打开？\\\").confirm(path => \\\"openFile://file://\\\" + path, PATH);\\n        }\\n    }),\\n    initialPath: Config[type],\\n    rootDirPath: Config.homePath,\\n    //onClickType: \\\"confirm\\\",\\n    //memory: \\\"FileManagement:memory\\\",\\n    fileType: \\\"\\\\.txt|\\\\.epub|.jpg\\\",\\n    //cHomeTips: \\\"是否使用海阔小程序打开[${name}]?\\\",\\n    //cSearchTips: \\\"是否使用海阔小程序打开[${path}]?\\\"\\n});\"},{\"col_type\":\"movie_3\",\"name\":\"#j.Config\",\"path\":\"Config.js\",\"rule\":\"js:\\nconst File = $.require(\\\"hiker://page/File.js?rule=本地资源管理\\\");\\n\\nlet localConfig = {};\\n\\ntry {\\n    localConfig = JSON.parse(File.readFile(getPath(\\\"hiker://files/rules/files/本地资源管理/config.json\\\").slice(7)));\\n} catch (e) {\\n    deleteFile(\\\"config.json\\\");\\n}\\nconst Config = Object.assign({\\n    homePath: getPath(\\\"hiker://files/localManager\\\").slice(7),\\n    logNum: 10,\\n    threadNum: 0,\\n    def_isPaginate: \\\"1\\\", //1默认开启分页，0默认关闭\\n    viewPageSize: 200,\\n    def_Pic: \\\"hiker://images/home_pic4\\\",\\n    def_Lord_Type: \\\"comic\\\",\\n    def_View_Style: \\\"text_1\\\",\\n    def_DoVi_Style: \\\"text_2\\\",\\n    def_DoVi_Type: \\\"1\\\", //0全部, 1未完成，2已完成\\n    def_isComicCompatible: \\\"0\\\",\\n    def_Comic_Style: \\\"text_1\\\"\\n}, localConfig);\\nconst PATHS = {\\n    novelPath: \\\"/小说/\\\",\\n    comicPath: \\\"/漫画/\\\",\\n    novelFullPath: \\\"/小说合并/\\\",\\n    externalImportPath: \\\"/外导小说/\\\",\\n    contentsCache: \\\"/目录缓存/\\\"\\n}\\n\\n\\nObject.keys(PATHS).forEach(key => Config[key] = Config.homePath + PATHS[key]);\\n\\n$.exports = Config;\"}],\"saved\":false,\"title\":\"本地资源管理\",\"version\":0,\"url\":\"hiker://page/help.view#noRefresh##noRecordHistory##noHistory#?keyword=novelComic\",\"col_type\":\"movie_3\",\"find_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}\",\"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    if (expand) {\\\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\\\n    }\\\\n    return pathList;\\\\n}\\\\n\\\\nfunction getFiles(path, type, expand) {\\\\n    let types = {\\\\n        \\\\\\\"file\\\\\\\": \\\\\\\"isFile\\\\\\\",\\\\n        \\\\\\\"dir\\\\\\\": \\\\\\\"isDirectory\\\\\\\"\\\\n    };\\\\n    let fileType = types[type];\\\\n    let file = new File(path);\\\\n    let array = file.listFiles() || [];\\\\n    let fileList = [];\\\\n    for (let i = 0; i < array.length; i++) {\\\\n        let file = array[i];\\\\n        if ((!fileType || file[fileType]()) && (!expand || file.getName().endsWith(expand))) {\\\\n            fileList.push(file);\\\\n        }\\\\n    }\\\\n    return fileList;\\\\n}\\\\n\\\\nfunction renameFile(fromPath, name) {\\\\n    let fromFile = new File(fromPath);\\\\n    let toFile = new File(fromFile.getParent() + \\\\\\\"/\\\\\\\" + name);\\\\n    try {\\\\n        if (!fromFile.exists()) {\\\\n            return false;\\\\n        }\\\\n        if (toFile.exists()) {\\\\n            if (!toFile.delete()) {\\\\n                return false;\\\\n            }\\\\n        }\\\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\\\n        return true;\\\\n    } catch (e) {\\\\n        log(e.toString());\\\\n        return false;\\\\n    }\\\\n}\\\\n\\\\nfunction moveFiles(fromPath, toPath) {\\\\n    let fromFile = new File(fromPath);\\\\n    let toFile = new File(toPath);\\\\n    try {\\\\n        if (!fromFile.exists()) {\\\\n            return false;\\\\n        }\\\\n        if (toFile.exists()) {\\\\n            if (!deleteFiles(toPath)) {\\\\n                return false;\\\\n            }\\\\n        }\\\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\\\n        return true;\\\\n    } catch (e) {\\\\n        log(e.toString());\\\\n        return false;\\\\n    }\\\\n}\\\\n\\\\nfunction fileWrite(path, content) {\\\\n    writeFile(\\\\\\\"file://\\\\\\\" + path, content)\\\\n}\\\\n\\\\nfunction fileWriteAppend(path, content) {\\\\n    let file = new File(path);\\\\n    let paths = file.toPath();\\\\n    if (file.exists()) {\\\\n        Files.write(paths, new javaString(content).getBytes(), StandardOpenOption.APPEND);\\\\n    } else {\\\\n        writeFile(\\\\\\\"file://\\\\\\\" + path, content);\\\\n    }\\\\n}\\\\n\\\\nfunction getTotalSizeOfFilesInDir(file) {\\\\n    if (file.isFile()) {\\\\n        return file.length();\\\\n    }\\\\n    let children = file.listFiles();\\\\n    let total = 0;\\\\n    if (children != null) {\\\\n        for (let child of children) {\\\\n            total += getTotalSizeOfFilesInDir(child);\\\\n        }\\\\n    }\\\\n    return total;\\\\n}\\\\n\\\\nfunction getFileSize(filePath) {\\\\n    //Byte\\\\n    let size = getTotalSizeOfFilesInDir(new File(filePath));\\\\n    if (size < 0) {\\\\n        return null;\\\\n    }\\\\n    let unitForm = [\\\\\\\"Byte\\\\\\\", \\\\\\\"KB\\\\\\\", \\\\\\\"MB\\\\\\\", \\\\\\\"GB\\\\\\\", \\\\\\\"TB\\\\\\\"];\\\\n    for (let i = 0, len = unitForm.length; i < len; i++) {\\\\n        if (size > 1024) {\\\\n            size /= 1024;\\\\n            continue;\\\\n        } else {\\\\n            return size.toFixed(2).replace(/(\\\\\\\\.00)$/, \\\\\\\"\\\\\\\") + unitForm[i];\\\\n        }\\\\n    }\\\\n    return \\\\\\\"ERROR:数值过大\\\\\\\";\\\\n}\\\\n//完整合并\\\\n/*\\\\nfunction fileCombine(filesInput, fileOut, extension, intercept) {\\\\n    with(javaScope) {\\\\n        const TMP_BUFFER_SIZE = 0x30000;\\\\n        const BUFFER_SIZE = 0x300000;\\\\n        //合并临时文件\\\\n        let inputFile = new File(filesInput);\\\\n        let tmpFile = new File(fileOut + \\\\\\\".tmp\\\\\\\");\\\\n        let tos = new BufferedOutputStream(new FileOutputStream(tmpFile));\\\\n        let inputFiles = inputFile.listFiles();\\\\n        let tbys = Array.newInstance(Byte.TYPE, TMP_BUFFER_SIZE);\\\\n        for (let file of inputFiles) {\\\\n            if (file.getName().endsWith(extension)) {\\\\n                let is = new FileInputStream(file);\\\\n                let len = 0;\\\\n                while ((len = is.read(tbys)) != -1) {\\\\n                    tos.write(tbys, 0, len);\\\\n                }\\\\n                is.close();\\\\n            }\\\\n        }\\\\n        tos.close();\\\\n        //规则替换规则;\\\\n        let outFile = new File(fileOut);\\\\n        if (typeof intercept === \\\\\\\"function\\\\\\\") {\\\\n            let tis = new FileInputStream(tmpFile);\\\\n            let os = new BufferedOutputStream(new FileOutputStream(outFile));\\\\n            let len = 0;\\\\n            let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\\\n            while ((len = tis.read(bys)) != -1) {\\\\n                let nbys = intercept(new String(bys,0,len));\\\\n                os.write(nbys, 0, nbys.length);\\\\n            }\\\\n            tmpFile.delete();\\\\n            tis.close();\\\\n            os.close();\\\\n        } else {\\\\n            if (outFile.exists()) {\\\\n                outFile.delete();\\\\n            }\\\\n            tmpFile.renameTo(outFile);\\\\n        }\\\\n    }\\\\n}*/\\\\n//残\\\\nfunction fileRule(filesInput, fileOut, intercept) {\\\\n    with(javaScope) {\\\\n        const BUFFER_SIZE = 0x300000;\\\\n        let tmpFile = new File(filesInput);\\\\n        if (!(tmpFile.exists() && tmpFile.isFile())) {\\\\n            return false;\\\\n        }\\\\n        let outFile = new File(fileOut);\\\\n\\\\n        let tis = new FileInputStream(tmpFile);\\\\n        let os = new BufferedOutputStream(new FileOutputStream(outFile));\\\\n        let len = 0;\\\\n        let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\\\n        while ((len = tis.read(bys)) != -1) {\\\\n            let nbys = intercept(new String(bys, 0, len));\\\\n            os.write(nbys, 0, nbys.length);\\\\n        }\\\\n        tmpFile.delete();\\\\n        tis.close();\\\\n        os.close();\\\\n        return true;\\\\n    }\\\\n}\\\\n\\\\nfunction readFile(path) {\\\\n    try {\\\\n        let paths = Paths.get(path);\\\\n        if (!Files.exists(paths)) return \\\\\\\"\\\\\\\";\\\\n        return String(new javaString(Files.readAllBytes(paths)));\\\\n    } catch {\\\\n        return \\\\\\\"\\\\\\\";\\\\n    }\\\\n}\\\\n$.exports = {\\\\n    getFileTime: (path) => getFileTime(path),\\\\n    getFilePath: (path, type, expand) => getFilePath(path, type, expand),\\\\n    deleteFiles: (path) => deleteFiles(path),\\\\n    renameFile: (path, name) => renameFile(path, name),\\\\n    moveFiles: (fromPath, toPath) => moveFiles(fromPath, toPath),\\\\n    fileWrite: (path, content) => fileWrite(path, content),\\\\n    fileWriteAppend: (path, content) => fileWriteAppend(path, content),\\\\n    getName: (path) => getName(path),\\\\n    getFileSize: (filePath) => getFileSize(filePath),\\\\n    fileRule: (filesInput, fileOut, intercept) => fileRule(filesInput, fileOut, intercept),\\\\n    copyFile: (source, target, isCover) => copyFile(source, target, isCover),\\\\n    readFile: (path) => readFile(path),\\\\n    getFiles: (path, type, expand) => getFiles(path, type, expand),\\\\n    getTotalSizeOfFilesInDir:(file)=>getTotalSizeOfFilesInDir(file)\\\\n}\\\"},{\\\"col_type\\\":\\\"text_2\\\",\\\"name\\\":\\\"#v.下载列表-普通下载\\\",\\\"path\\\":\\\"download.view\\\",\\\"rule\\\":\\\"js:\\\\nconst viewConfig = Object.assign({\\\\n    chapterList: [],\\\\n    info: {},\\\\n    defaultView: \\\\\\\"0\\\\\\\"\\\\n}, MY_PARAMS);\\\\nviewConfig.info = Object.assign({\\\\n    ruleName: \\\\\\\"\\\\\\\",\\\\n    bookName: \\\\\\\"\\\\\\\",\\\\n    bookTopPic: \\\\\\\"\\\\\\\",\\\\n    parseCode: \\\\\\\"\\\\\\\",\\\\n    decode: undefined,\\\\n    type: \\\\\\\"comic\\\\\\\",\\\\n    comicScheme: \\\\\\\"1\\\\\\\",\\\\n    bookId:\\\\\\\"\\\\\\\",\\\\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.js\\\\\\\");\\\\n\\\\nviewConfig.info.bookName = Tool.textShield(viewConfig.info.bookName);\\\\nviewConfig.info.ruleName = Tool.textShield(viewConfig.info.ruleName);\\\\n\\\\nconst MY_ID = info.ruleName + \\\\\\\"//\\\\\\\" + info.bookName+\\\\\\\"//\\\\\\\"+info.bookId;\\\\nlet boid=info.bookId?\\\\\\\"$\\\\\\\"+info.bookId:\\\\\\\"\\\\\\\";\\\\nconst cpath=\\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + info.bookName+boid;\\\\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    if (chapterList.startsWith(\\\\\\\"hiker://files/\\\\\\\")) {\\\\n        chapterList = getPath(chapterList).slice(7);\\\\n        backupChapterList = chapterList;\\\\n    }\\\\n    chapterList = JSON.parse(request(\\\\\\\"file://\\\\\\\" + chapterList) || \\\\\\\"[]\\\\\\\");\\\\n}\\\\nlet chapterAll = chapterList;\\\\nchapterList = chapterList.map((item, CID) => {\\\\n    item.CID = CID;\\\\n    item.title = Tool.textShield(item.title);\\\\n    return item;\\\\n});\\\\nlet pageNum = Number(getMyVar(MY_ID + \\\\\\\":pageNum\\\\\\\", \\\\\\\"1\\\\\\\"));\\\\nlet chapterChunk = [chapterList].concat(Tool.chunk(chapterList, Config.viewPageSize));\\\\nchapterList = chapterChunk[pageNum] || [];\\\\nconst def_DoVi_Style = chapterAll.length === 1 ? \\\\\\\"text_center_1\\\\\\\" : Config.def_DoVi_Style;\\\\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 + cpath + \\\\\\\"/\\\\\\\" + 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\\\\\\\"] +cpath, \\\\\\\"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 + cpath + \\\\\\\"/\\\\\\\" + 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\\\\\\\"] + cpath, \\\\\\\"file\\\\\\\", \\\\\\\".txt\\\\\\\").forEach((file) => {\\\\n        let att = Tool.split(file.name, \\\\\\\"$\\\\\\\", 2);\\\\n        if (att.length === 3 && att[1] === (\\\\\\\"A\\\\\\\")) {\\\\n            record.push(att[2].slice(0, att[2].lastIndexOf(\\\\\\\".\\\\\\\")));\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nfunction clickDownload(item, info, MY_ID, i) {\\\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let ElementIndex = loadingTeam.indexOf(i);\\\\n    if (ElementIndex > -1) return \\\\\\\"toast://正在下载\\\\\\\";\\\\n\\\\n    loadingTeam.push(i);\\\\n    putMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", JSON.stringify(loadingTeam));\\\\n    updateItem({\\\\n        title: \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n        }\\\\n    });\\\\n    let result = \\\\\\\"toast://下载失败\\\\\\\";\\\\n    try {\\\\n        toast(\\\\\\\"开始下载:\\\\\\\" + item.title);\\\\n        let download = $.require(\\\\\\\"hiker://page/Download.exe.js\\\\\\\");\\\\n        result = download(item, info, i, MY_ID);\\\\n        updateItem({\\\\n            title: \\\\\\\"““\\\\\\\" + item.title + \\\\\\\"””\\\\\\\",\\\\n            url: \\\\\\\"toast://已下载\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n    } catch (e) {\\\\n        updateItem({\\\\n            title: item.title,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        log(e.toString());\\\\n    } finally {\\\\n        loadingTeam.splice(ElementIndex, 1);\\\\n        putMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", JSON.stringify(loadingTeam));\\\\n    }\\\\n    return result;\\\\n}\\\\n\\\\nfunction singleView() {\\\\n    layout.push({\\\\n        title: \\\\\\\"反转列表\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReverse, MY_ID) => {\\\\n            putMyVar(MY_ID + \\\\\\\":isReverse\\\\\\\", isReverse === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, isReverse, MY_ID),\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?id=33nvDqbHH7HW&size=48&format=gif&token=\\\\\\\",\\\\n        col_type: \\\\\\\"icon_2\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"批量下载\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            if (loadingTeam.length > 0) return \\\\\\\"toast://还有任务没有完成\\\\\\\";\\\\n            if (getAppVersion() < 2594) return \\\\\\\"toast://未开放\\\\\\\";\\\\n            putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n        }, MY_ID),\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=0uafaMNzxj88&token=\\\\\\\",\\\\n        col_type: \\\\\\\"icon_2\\\\\\\"\\\\n    });\\\\n    setType();\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    let loadingTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":loadingTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\\\n        let is_download = record.includes(item.title);\\\\n        if (is_download && tagFilter !== \\\\\\\"1\\\\\\\") {\\\\n            chapterTeam.push(comFun(item.CID, item));\\\\n        } else if (!is_download && tagFilter !== \\\\\\\"2\\\\\\\") {\\\\n            chapterTeam.push({\\\\n                title: loadingTeam.includes(item.CID) ? \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\" : item.title,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(clickDownload, item, info, MY_ID, item.CID),\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"#\\\\\\\" + item.CID\\\\n                },\\\\n                col_type: def_DoVi_Style\\\\n            });\\\\n        }\\\\n    }\\\\n}\\\\n\\\\nfunction clickChoose(title, MY_ID, i) {\\\\n    let isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n    if (isStart === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在下载...\\\\\\\";\\\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let ElementIndex = batchTeam.indexOf(i);\\\\n    if (ElementIndex > -1) {\\\\n        updateItem({\\\\n            title: title,\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        batchTeam.splice(ElementIndex, 1);\\\\n    } else {\\\\n        updateItem({\\\\n            title: \\\\\\\"‘‘\\\\\\\" + title + \\\\\\\"’’\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"#\\\\\\\" + i\\\\n            }\\\\n        });\\\\n        batchTeam.push(i);\\\\n    }\\\\n    putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n}\\\\n\\\\nfunction batchView() {\\\\n    layout.push({\\\\n        title: \\\\\\\"单选下载\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?id=PIicvF6ebzMn&size=48&format=gif&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\") === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在批量下载\\\\\\\";\\\\n            putMyVar(MY_ID + \\\\\\\":viewMode\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    let start = Config.viewPageSize * Math.max(pageNum - 1, 0);\\\\n    let end = start + chapterList.length;\\\\n    layout.push({\\\\n        title: \\\\\\\"选择全部\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=1HVcHLoNzrit&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((start, end, MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\") === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在下载哦~\\\\\\\";\\\\n            const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n            let chooseTeam = Tool.range(start, end);\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = Array.from(new Set(batchTeam.concat(chooseTeam)));\\\\n            let completed = JSON.parse(getMyVar(MY_ID + \\\\\\\":completed\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = batchTeam.filter((i) => !completed.includes(i));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, start, end, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"取消全部\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=HzEjPpI3NL8D&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((start, end, MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\") === \\\\\\\"1\\\\\\\") return \\\\\\\"toast://正在下载哦~\\\\\\\";\\\\n            const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n            let chooseTeam = new Set(Tool.range(start, end));\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            batchTeam = batchTeam.filter(x => !chooseTeam.has(x));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, start, end, MY_ID),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"确认选中\\\\\\\",\\\\n        pic_url: \\\\\\\"https://img.icons8.com/?format=gif&id=tMrvtc6T9hVb&token=\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            if (getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"-1\\\\\\\") !== \\\\\\\"-1\\\\\\\") {\\\\n                return \\\\\\\"toast://正在下载哦~\\\\\\\";\\\\n            }\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            return batchTeam.length === 0 ? \\\\\\\"toast://你还什么都没有选\\\\\\\" : \\\\\\\"hiker://page/Batch.view#noRefresh##noHistory##noRecordHistory#\\\\\\\";\\\\n        }, MY_ID),\\\\n        extra: {\\\\n            newWindow: true,\\\\n            windowId: MY_ID + \\\\\\\"//批量下载\\\\\\\",\\\\n            MY_ID: MY_ID,\\\\n            chapterList: backupChapterList,\\\\n            info: info\\\\n        },\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    setType();\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let completed = [];\\\\n    for (let i = 0, item = chapterList[0]; i < chapterList.length; item = chapterList[++i]) {\\\\n        let is_download = record.includes(item.title);\\\\n\\\\n        if (is_download) {\\\\n            completed.push(item.CID);\\\\n            if (tagFilter !== \\\\\\\"1\\\\\\\") {\\\\n                chapterTeam.push(comFun(item.CID, item));\\\\n            }\\\\n        } else if (!is_download && tagFilter !== \\\\\\\"2\\\\\\\") {\\\\n            chapterTeam.push({\\\\n                title: batchTeam.includes(item.CID) ? \\\\\\\"‘‘\\\\\\\" + item.title + \\\\\\\"’’\\\\\\\" : item.title,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(clickChoose, item.title, MY_ID, item.CID),\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"#\\\\\\\" + item.CID\\\\n                },\\\\n                col_type: def_DoVi_Style\\\\n            });\\\\n        }\\\\n    }\\\\n    putMyVar(MY_ID + \\\\\\\":completed\\\\\\\", JSON.stringify(completed));\\\\n}\\\\nswitch (viewMode) {\\\\n    case \\\\\\\"0\\\\\\\":\\\\n        singleView();\\\\n        break;\\\\n    case \\\\\\\"1\\\\\\\":\\\\n        batchView();\\\\n        break;\\\\n}\\\\nif (isReverse === \\\\\\\"1\\\\\\\") {\\\\n    chapterTeam.reverse();\\\\n}\\\\nlayout.push.apply(layout, chapterTeam);\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.批量下载器\\\",\\\"path\\\":\\\"Batch.view\\\",\\\"rule\\\":\\\"js:\\\\nlet {\\\\n    chapterList,\\\\n    info,\\\\n    MY_ID\\\\n} = MY_PARAMS;\\\\nsetPageTitle(\\\\\\\"下载器|\\\\\\\"+info.bookName);\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString((MY_ID) => {\\\\n    clearMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":status\\\\\\\");\\\\n    clearMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\");\\\\n    refreshPage();\\\\n}, MY_ID));\\\\n\\\\nlet isStart = getMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet layout = [];\\\\n\\\\nlet batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\nif(typeof chapterList === \\\\\\\"string\\\\\\\"){\\\\n    chapterList = JSON.parse(request(\\\\\\\"file://\\\\\\\"+chapterList)||\\\\\\\"[]\\\\\\\");\\\\n}\\\\nlet chapterTeam = batchTeam.map(v => {\\\\n    let chapterItem = chapterList[v];\\\\n    chapterItem.CID = v;\\\\n    return chapterItem;\\\\n});\\\\nif (isStart === \\\\\\\"0\\\\\\\") {\\\\n    layout.push({\\\\n        title: \\\\\\\"开始下载[\\\\\\\" + chapterTeam.length + \\\\\\\"]\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((chapterTeam, info, MY_ID) => {\\\\n            putMyVar(MY_ID + \\\\\\\":isStart\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage(false);\\\\n            let download = $.require(\\\\\\\"hiker://page/BatchStatistics.js\\\\\\\");\\\\n            if(info.type===\\\\\\\"comic\\\\\\\"&&info.comicScheme===\\\\\\\"1\\\\\\\"){\\\\n                download=download.b;\\\\n            }else{\\\\n                download=download.a;\\\\n            }\\\\n            return download(chapterTeam, info, MY_ID) || \\\\\\\"toast://下载错误\\\\\\\";\\\\n        }, chapterTeam, info, MY_ID),\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||开始下载\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"任务列表：\\\\\\\",\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    });\\\\n    for (let item of chapterTeam) {\\\\n        layout.push({\\\\n            title: item.title,\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_2\\\\\\\"\\\\n        });\\\\n    }\\\\n\\\\n} else {\\\\n    layout.push({\\\\n        title: \\\\\\\"下载进度:0/\\\\\\\"+chapterTeam.length,\\\\n        desc: \\\\\\\"““””▇▇▇▇▇▇▇▇▇▇\\\\\\\".fontcolor(\\\\\\\"#e5e1e4\\\\\\\")+\\\\\\\" 0%\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||下载进度\\\\\\\",\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"后台下载\\\\\\\",\\\\n        url: \\\\\\\"func://background\\\\\\\",\\\\n        col_type: \\\\\\\"text_2\\\\\\\"\\\\n    });\\\\n\\\\n    layout.push({\\\\n        title: [\\\\\\\"[取消下载]\\\\\\\", \\\\\\\"[正在停止...]\\\\\\\", \\\\\\\"[返回]\\\\\\\", \\\\\\\"[处理失败]\\\\\\\", \\\\\\\"[重新开始]\\\\\\\"][status],\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((MY_ID) => {\\\\n            let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            if (status === \\\\\\\"0\\\\\\\") {\\\\n                putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n                updateItem({\\\\n                    title: \\\\\\\"[正在停止...]\\\\\\\",\\\\n                    extra: {\\\\n                        id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                    }\\\\n                });\\\\n                return \\\\\\\"toast://正在取消下载任务\\\\\\\";\\\\n            } else if (status === \\\\\\\"1\\\\\\\") {\\\\n                return \\\\\\\"toast://正在暂停...\\\\\\\";\\\\n            } else if (status === \\\\\\\"2\\\\\\\") {\\\\n                back();\\\\n                return \\\\\\\"toast://已退出下载器\\\\\\\";\\\\n            } else if ([\\\\\\\"3\\\\\\\", \\\\\\\"4\\\\\\\"].includes(status)) {\\\\n                clearMyVar(MY_ID + \\\\\\\":isStart\\\\\\\");\\\\n                clearMyVar(MY_ID + \\\\\\\":status\\\\\\\");\\\\n                clearMyVar(MY_ID + \\\\\\\":log\\\\\\\");\\\\n                refreshPage();\\\\n                return \\\\\\\"toast://重新点击下载\\\\\\\"\\\\n            }\\\\n        }, MY_ID),\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"<strong>下载日志</strong>\\\\\\\".big(),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n        \\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"||日志\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title:\\\\\\\"““””$>\\\\\\\"+\\\\\\\"开始下载......\\\\\\\".fontcolor(\\\\\\\"#00ff00\\\\\\\"),\\\\n        url:\\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_1\\\\\\\",\\\\n        extra: {\\\\n            id: MY_ID + \\\\\\\"#log#0\\\\\\\",\\\\n            lineVisible:false\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.批量下载统计\\\",\\\"path\\\":\\\"BatchStatistics.js\\\",\\\"rule\\\":\\\"const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\n\\\\n$.exports.a = function(chapterTeam, info, MY_ID) {\\\\n    if (chapterTeam.length === 0) {\\\\n        return \\\\\\\"toast://空的下载队列\\\\\\\";\\\\n    }\\\\n\\\\n    var count = 0;\\\\n    var taskCount = chapterTeam.length;\\\\n    var successCID = [];\\\\n    var failName = [];\\\\n    var logCount = 1;\\\\n    var taskTeam = chapterTeam.map(chapterItem => ({\\\\n        func: task,\\\\n        id: chapterItem.title,\\\\n        param: {\\\\n            chapterItem: chapterItem,\\\\n            info: info,\\\\n            MY_ID: MY_ID\\\\n        }\\\\n    }));\\\\n    let logNum = Config.logNum;\\\\n\\\\n\\\\n    function putLog(text) {\\\\n        log(text);\\\\n        if (logCount >= logNum) {\\\\n            deleteItem(MY_ID + \\\\\\\"#log#\\\\\\\" + (logCount - 10));\\\\n        }\\\\n        addItemAfter(MY_ID + \\\\\\\"||日志\\\\\\\", {\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            title: \\\\\\\"$>\\\\\\\" + text,\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false,\\\\n                id: MY_ID + \\\\\\\"#log#\\\\\\\" + logCount\\\\n            }\\\\n        });\\\\n        logCount++;\\\\n    }\\\\n\\\\n    function task(taskParam) {\\\\n        let result = $.require(\\\\\\\"hiker://page/Batch.exe.js\\\\\\\")(taskParam);\\\\n        return result;\\\\n    }\\\\n\\\\n    function listener(perch, id, error, CID) {\\\\n        count++;\\\\n        let isSuccess = false;\\\\n        if (error != null) {\\\\n            failName.push(id);\\\\n            putLog(\\\\\\\"[listener]下载失败：\\\\\\\" + id + \\\\\\\"<ERROR@ \\\\\\\" + error + \\\\\\\">\\\\\\\");\\\\n        } else if (CID >= 0) {\\\\n            successCID.push(CID);\\\\n            let ratio = (count / taskCount).toFixed(4);\\\\n            let stripCount = Math.ceil(ratio * 10);\\\\n            isSuccess = true;\\\\n            updateItem({\\\\n                title: \\\\\\\"下载进度：\\\\\\\" + successCID.length + \\\\\\\"/\\\\\\\" + taskCount,\\\\n                desc: \\\\\\\"““””\\\\\\\" + \\\\\\\"▇\\\\\\\".repeat(stripCount).fontcolor(\\\\\\\"#ffac2d\\\\\\\") + \\\\\\\"▇\\\\\\\".repeat(10 - stripCount).fontcolor(\\\\\\\"#e5e1e4\\\\\\\") + \\\\\\\" \\\\\\\" + String((ratio * 100)).slice(0, 5) + \\\\\\\"%\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载进度\\\\\\\"\\\\n                }\\\\n            });\\\\n            putLog(\\\\\\\"[listener]已完成下载：\\\\\\\" + id);\\\\n        } else if (CID === -1) {\\\\n            failName.push(id);\\\\n            putLog(\\\\\\\"[listener]已停止：\\\\\\\" + id);\\\\n            count = taskCount;\\\\n        }\\\\n\\\\n        if (taskCount !== count) return;\\\\n        if (successCID.length === taskCount) {\\\\n            updateItem({\\\\n                desc: \\\\\\\"““””\\\\\\\" + \\\\\\\"▇\\\\\\\".repeat(10).fontcolor(\\\\\\\"#00ff00\\\\\\\") + \\\\\\\" 100%\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载进度\\\\\\\"\\\\n                }\\\\n            });\\\\n        }\\\\n        let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n        let failTeam = batchTeam.filter(v => !successCID.includes(v));\\\\n        putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(failTeam));\\\\n        if (failTeam.length > 0 && status !== \\\\\\\"1\\\\\\\") {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"3\\\\\\\");\\\\n            putLog(\\\\\\\"下载失败:[\\\\\\\" + failName.join(\\\\\\\"]，[\\\\\\\") + \\\\\\\"]。\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[处理失败]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        } else if (failTeam.length > 0 && status === \\\\\\\"1\\\\\\\") {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"4\\\\\\\");\\\\n            putLog(\\\\\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[重新开始]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n            return \\\\\\\"break\\\\\\\";\\\\n        } else {\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"2\\\\\\\");\\\\n            putLog(\\\\\\\"下载任务[\\\\\\\" + info.bookName + \\\\\\\"]已全部成功完成\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[返回]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n        }\\\\n        toast(\\\\\\\"下载任务[\\\\\\\" + info.bookName + \\\\\\\"]已完成\\\\\\\");\\\\n    }\\\\n    let taskTeamChunk = [];\\\\n    if (Config.threadNum > 0) {\\\\n        taskTeamChunk = Tool.chunk(taskTeam, Config.threadNum);\\\\n    } else {\\\\n        taskTeamChunk = [taskTeam];\\\\n    }\\\\n    for (let taskList of taskTeamChunk) {\\\\n        be(taskList, {\\\\n            func: listener\\\\n        });\\\\n        let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n        if (status === \\\\\\\"1\\\\\\\") {\\\\n            let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n            //let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n            let failTeam = batchTeam.filter(v => !successCID.includes(v));\\\\n            putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(failTeam));\\\\n            putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"4\\\\\\\");\\\\n            putLog(\\\\\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\\\\\");\\\\n            updateItem({\\\\n                title: \\\\\\\"[重新开始]\\\\\\\",\\\\n                extra: {\\\\n                    id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n                }\\\\n            });\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }\\\\n\\\\n    }\\\\n\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n};\\\\n\\\\n$.exports.b = function comic(chapterTeam, info, MY_ID) {\\\\n    if (chapterTeam.length === 0) {\\\\n        return \\\\\\\"toast://空的下载队列\\\\\\\";\\\\n    }\\\\n    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n\\\\n    let logNum = Config.logNum;\\\\n    let logCount = 0;\\\\n\\\\n    function putLog(text) {\\\\n        log(text);\\\\n        if (logCount >= logNum) {\\\\n            deleteItem(MY_ID + \\\\\\\"#log#\\\\\\\" + (logCount - 10));\\\\n        }\\\\n        addItemAfter(MY_ID + \\\\\\\"||日志\\\\\\\", {\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            title: \\\\\\\"$>\\\\\\\" + text,\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false,\\\\n                id: MY_ID + \\\\\\\"#log#\\\\\\\" + logCount\\\\n            }\\\\n        });\\\\n        logCount++;\\\\n    }\\\\n\\\\n    function task(taskParam) {\\\\n        const Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n        for (let i = 0; i < 10; i++) {\\\\n            try {\\\\n                let pic = Tool.hikerPic(taskParam.url);\\\\n                Tool.picDownload(pic[0], taskParam.chapterPath + (taskParam.i + 1) + \\\\\\\".jpg\\\\\\\", pic[1], taskParam.decode);\\\\n                if (getMyVar(taskParam.MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n                    return -1;\\\\n                }\\\\n                errorNum = 0;\\\\n                break;\\\\n            } catch (e) {\\\\n                if (i === 9) {\\\\n                    throw e;\\\\n                }\\\\n            }\\\\n        }\\\\n        return taskParam.CID;\\\\n    }\\\\n    let count = 0;\\\\n    let totalCount = 0;\\\\n    let successCID = [];\\\\n\\\\n    function listener(param, id, error, result) {\\\\n        try {\\\\n            totalCount++;\\\\n\\\\n            if (error != null) {\\\\n                putLog(\\\\\\\"[listener]下载失败：\\\\\\\" + id + \\\\\\\"<ERROR@ \\\\\\\" + error + \\\\\\\">\\\\\\\");\\\\n            } else if (result === -1) {\\\\n                putLog(\\\\\\\"[listener]已停止：\\\\\\\" + id);\\\\n                totalCount = param.pivCount;\\\\n            } else {\\\\n                count++;\\\\n                let ratio = ((count / param.pivCount)).toFixed(4);\\\\n                let stripCount = Math.ceil(ratio * 10);\\\\n                if (param.pivCount === totalCount && totalCount === count) {\\\\n                    successCID.push(param.CID);\\\\n                }\\\\n                updateItem({\\\\n                    title: \\\\\\\"下载进度：\\\\\\\" + (successCID.length) + \\\\\\\"/\\\\\\\" + param.total,\\\\n                    desc: \\\\\\\"““””\\\\\\\" + \\\\\\\"▇\\\\\\\".repeat(stripCount).fontcolor(\\\\\\\"#ffac2d\\\\\\\") + \\\\\\\"▇\\\\\\\".repeat(10 - stripCount).fontcolor(\\\\\\\"#e5e1e4\\\\\\\") + \\\\\\\" \\\\\\\" + String((ratio * 100)).slice(0, 5) + \\\\\\\"%\\\\\\\",\\\\n                    extra: {\\\\n                        id: MY_ID + \\\\\\\"||下载进度\\\\\\\"\\\\n                    }\\\\n                });\\\\n                //putLog(\\\\\\\"[listener]已完成下载：\\\\\\\" + id);\\\\n            }\\\\n            if (totalCount !== param.pivCount) return;\\\\n            if (totalCount === count) {\\\\n                File.renameFile(param.chapterPath, param.CID + \\\\\\\"$A$\\\\\\\" + Tool.textShield(param.title));\\\\n            }\\\\n            totalCount = count = 0;\\\\n            return \\\\\\\"break\\\\\\\";\\\\n        } catch (e) {\\\\n            log(e.toString());\\\\n        }\\\\n    }\\\\n    let taskTeam = [];\\\\n    let mainPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + Tool.textShield(info.bookName) + \\\\\\\"/\\\\\\\";\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + \\\\\\\".jpg\\\\\\\", bookTopPic[1], info.decode);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误> \\\\\\\" + e.message);\\\\n        }\\\\n    }\\\\n\\\\n    for (let k = 0; k < chapterTeam.length; k++) {\\\\n        let item = chapterTeam[k];\\\\n        let order = k;\\\\n        let chapterPath = mainPath + item.CID + \\\\\\\"$B$\\\\\\\" + Tool.textShield(item.title) + \\\\\\\"/\\\\\\\";\\\\n        let picList = [];\\\\n        try {\\\\n            let getPicList = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"index\\\\\\\", \\\\\\\"title\\\\\\\", \\\\\\\"return\\\\\\\" + info.parseCode);\\\\n            picList = getPicList(item.url, item.url, k, item.title);\\\\n            if (typeof picList === \\\\\\\"string\\\\\\\") {\\\\n                picList = picList.replace(\\\\\\\"pics://\\\\\\\", \\\\\\\"\\\\\\\").split(\\\\\\\"&&\\\\\\\");\\\\n            }\\\\n        } catch (e) {\\\\n            putLog(\\\\\\\"<漫画图片解析错误> \\\\\\\" + e.message);\\\\n            continue;\\\\n        }\\\\n        if (picList.length === 0) {\\\\n            putLog(\\\\\\\"<漫画图片解析错误：图片链接返回为空>\\\\\\\");\\\\n            continue;\\\\n        }\\\\n        picList = picList.filter(p => p);\\\\n        var taskTeam = picList.map((url, i) => ({\\\\n            func: task,\\\\n            id: i,\\\\n            param: {\\\\n                url: url,\\\\n                i: i,\\\\n                chapterPath: chapterPath,\\\\n                MY_ID: MY_ID,\\\\n                decode: info.decode\\\\n            }\\\\n        }));\\\\n        be(taskTeam, {\\\\n            func: listener,\\\\n            param: {\\\\n                pivCount: picList.length,\\\\n                total: chapterTeam.length,\\\\n                order: order,\\\\n                CID: item.CID,\\\\n                title: item.title,\\\\n                chapterPath: chapterPath\\\\n            }\\\\n        });\\\\n        if (getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n            break;\\\\n        }\\\\n    }\\\\n\\\\n    let status = getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n    java.lang.Thread.sleep(40);\\\\n    //let batchTeam = JSON.parse(getMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", \\\\\\\"[]\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n    let failTeam = chapterTeam.filter(v => !successCID.includes(v.CID));\\\\n    let failName = failTeam.map(item => item.title);\\\\n    let batchTeam = failTeam.map(item => item.CID);\\\\n\\\\n    if (failTeam.length > 0 && status !== \\\\\\\"1\\\\\\\") {\\\\n        putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n        putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"3\\\\\\\");\\\\n        putLog(\\\\\\\"下载失败:[\\\\\\\" + failName.join(\\\\\\\"]，[\\\\\\\") + \\\\\\\"]。\\\\\\\");\\\\n        updateItem({\\\\n            title: \\\\\\\"[处理失败]\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n            }\\\\n        });\\\\n    } else if (failTeam.length > 0 && status === \\\\\\\"1\\\\\\\") {\\\\n        putMyVar(MY_ID + \\\\\\\":batchTeam\\\\\\\", JSON.stringify(batchTeam));\\\\n        putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"4\\\\\\\");\\\\n        putLog(\\\\\\\"[listener]#已停止所有任务，但已有进度不会消失#\\\\\\\");\\\\n        updateItem({\\\\n            title: \\\\\\\"[重新开始]\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n            }\\\\n        });\\\\n    } else {\\\\n        putMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"2\\\\\\\");\\\\n        putLog(\\\\\\\"下载任务[\\\\\\\" + info.bookName + \\\\\\\"]已全部成功完成\\\\\\\");\\\\n        updateItem({\\\\n            title: \\\\\\\"[返回]\\\\\\\",\\\\n            extra: {\\\\n                id: MY_ID + \\\\\\\"||下载控制\\\\\\\"\\\\n            }\\\\n        });\\\\n    }\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.批量主程序\\\",\\\"path\\\":\\\"Batch.exe.js\\\",\\\"rule\\\":\\\"const Mian = $.require(\\\\\\\"mainDownload\\\\\\\");\\\\nfunction comic(taskParam) {\\\\n    let {\\\\n        chapterItem,\\\\n        info,\\\\n        MY_ID,\\\\n    } = taskParam;\\\\n    return Mian.comic(chapterItem, info, chapterItem.CID, MY_ID, true)||chapterItem.CID;\\\\n}\\\\n\\\\nfunction novel(taskParam) {\\\\n    let {\\\\n        chapterItem,\\\\n        info,\\\\n        MY_ID,\\\\n    } = taskParam;\\\\n    return Mian.novel(chapterItem, info, chapterItem.CID,MY_ID, true)||chapterItem.CID;\\\\n    //File.renameFile(chapterPath, chapterItem.CID + \\\\\\\"$A$\\\\\\\" + chapterItem.title);\\\\n}\\\\nvar $exe = {\\\\n    comic: comic,\\\\n    novel: novel\\\\n};\\\\n$.exports = function(taskParam) {\\\\n    return $exe[taskParam.info.type](taskParam);\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.普通主程序\\\",\\\"path\\\":\\\"Download.exe.js\\\",\\\"rule\\\":\\\"const Mian = $.require(\\\\\\\"mainDownload\\\\\\\");\\\\nfunction novel(item, info, order, MY_ID) {\\\\n    Mian.novel(item, info, order);\\\\n    return \\\\\\\"toast://\\\\\\\" + info.bookName + \\\\\\\"@\\\\\\\" + item.title + \\\\\\\" 下载完成\\\\\\\";\\\\n}\\\\n\\\\nfunction comic(item, info, order, MY_ID) {\\\\n    Mian.comic(item, info, order);\\\\n    return \\\\\\\"toast://\\\\\\\" + info.bookName + \\\\\\\"@\\\\\\\" + item.title + \\\\\\\" 下载完成\\\\\\\";\\\\n}\\\\nvar $exe = {\\\\n    comic: comic,\\\\n    novel: novel\\\\n};\\\\n$.exports = function(item, info, order, MY_ID) {\\\\n    return $exe[info.type](item, info, order, MY_ID);\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#f.通用工具\\\",\\\"path\\\":\\\"Tool.js\\\",\\\"rule\\\":\\\"const v = {\\\\n    split(text, target, count) {\\\\n        count = count === undefined ? 1 : count;\\\\n        let array = [text];\\\\n        for (let i = 0; i < count; i++) {\\\\n            text = array[i];\\\\n            let index = text.indexOf(target);\\\\n            if (index === -1) {\\\\n                break;\\\\n            }\\\\n            array[i] = text.slice(0, index);\\\\n            array[i + 1] = text.slice(index + target.length);\\\\n        }\\\\n        return array;\\\\n    },\\\\n    chunk(arr, size) {\\\\n        var result = [];\\\\n        for (var i = 0, len = arr.length; i < len; i += size) {\\\\n            result.push(arr.slice(i, i + size));\\\\n        }\\\\n        return result;\\\\n    },\\\\n    hikerPic(url) {\\\\n        var headers = {};\\\\n        let urls = url.split(\\\\\\\"@\\\\\\\");\\\\n        let picUrl = urls.shift();\\\\n        let length = urls.length;\\\\n        for (let i = 0; i < length; i++) {\\\\n            let [key, value] = v.split(urls[i], \\\\\\\"=\\\\\\\");\\\\n            if (key === \\\\\\\"headers\\\\\\\") {\\\\n                try {\\\\n                    Object.assign(headers, JSON.parse(value));\\\\n                } catch (e) {\\\\n                    log(e.toString());\\\\n                }\\\\n            } else if (key.includes(\\\\\\\".\\\\\\\") || key.includes(\\\\\\\"?\\\\\\\")) {\\\\n                picUrl += \\\\\\\"@\\\\\\\" + key + (value ? \\\\\\\"=\\\\\\\" + value : \\\\\\\"\\\\\\\");\\\\n            } else if (key !== \\\\\\\"js\\\\\\\") {\\\\n                headers[key] = value;\\\\n            }\\\\n        }\\\\n        return [picUrl, headers];\\\\n    },\\\\n    range(start, end) {\\\\n        return Array(end - start).fill(0).map((el, i) => start + i);\\\\n    },\\\\n    picDownload(url, path, headers, deciphe) {\\\\n        if (typeof deciphe === \\\\\\\"string\\\\\\\" && deciphe.length > 0) {\\\\n            let instream;\\\\n            let outstream;\\\\n            let file;\\\\n            try {\\\\n                file = new java.io.File(path);\\\\n                if (file.exists()) {\\\\n                    return;\\\\n                }\\\\n                let dir = file.getParentFile();\\\\n                if (dir != null && !dir.exists()) {\\\\n                    dir.mkdirs();\\\\n                }\\\\n                instream = fetch(url, {\\\\n                    headers: headers,\\\\n                    inputStream: true\\\\n                });\\\\n\\\\n                outstream = new java.io.FileOutputStream(path);\\\\n                let t = $.hiker.input,\\\\n                    c = $.hiker.url;\\\\n                $.hiker.input = instream;\\\\n                $.hiker.url = url;\\\\n                let picin = (new Function(\\\\\\\"return \\\\\\\" + deciphe))();\\\\n                $.hiker.input = t;\\\\n                $.hiker.url = c;\\\\n                let buf = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 1024);\\\\n                let len;\\\\n                while ((len = picin.read(buf)) != -1) {\\\\n                    outstream.write(buf, 0, len);\\\\n                }\\\\n                closeMe(instream);\\\\n                closeMe(outstream);\\\\n            } catch (e) {\\\\n                closeMe(instream);\\\\n                closeMe(outstream);\\\\n                if (file instanceof java.io.File && file.exists()) {\\\\n                    file.delete();\\\\n                }\\\\n                log(\\\\\\\"<解密下载Error>\\\\\\\" + e.toString())\\\\n                throw e;\\\\n            } finally {\\\\n                closeMe(instream);\\\\n                closeMe(outstream);\\\\n            }\\\\n\\\\n        } else {\\\\n            requireDownload(url, path, headers);\\\\n        }\\\\n    },\\\\n    textShield(text) {\\\\n        let e = /#|:|&|\\\\\\\\||\\\\\\\\^|@|\\\\\\\\<|\\\\\\\\>|%|\\\\\\\\/|\\\\\\\\?|\\\\\\\\$/g;\\\\n        return text.replace(e, \\\\\\\"_\\\\\\\");\\\\n    }\\\\n    \\\\n}\\\\n\\\\n$.exports = v;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#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.js\\\\\\\");\\\\n    let type = getMyVar(\\\\\\\".type\\\\\\\", getItem(\\\\\\\"main:type\\\\\\\", Config.def_Lord_Type));\\\\n    let tgnum = getMyVar(\\\\\\\".tgnum\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n    addListener(\\\\\\\"onClose\\\\\\\", $.toString((MY_ID) => {\\\\n        clearMyVar(\\\\\\\"searchKey\\\\\\\");\\\\n        clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n    }));\\\\n    layout.push({\\\\n        title: type === \\\\\\\"comic\\\\\\\" ? \\\\\\\"◉漫画\\\\\\\" : \\\\\\\"○漫画\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((type) => {\\\\n            if (type === \\\\\\\"comic\\\\\\\") return \\\\\\\"hiker://empty\\\\\\\";\\\\n            putMyVar(\\\\\\\".type\\\\\\\", \\\\\\\"comic\\\\\\\");\\\\n            setItem(\\\\\\\"main:type\\\\\\\", \\\\\\\"comic\\\\\\\");\\\\n            clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, type),\\\\n        col_type: \\\\\\\"text_3\\\\\\\",\\\\n    });\\\\n    layout.push({\\\\n        title: type === \\\\\\\"novel\\\\\\\" ? \\\\\\\"◉小说\\\\\\\" : \\\\\\\"○小说\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((type) => {\\\\n            if (type === \\\\\\\"novel\\\\\\\") return \\\\\\\"hiker://empty\\\\\\\";\\\\n            putMyVar(\\\\\\\".type\\\\\\\", \\\\\\\"novel\\\\\\\");\\\\n            setItem(\\\\\\\"main:type\\\\\\\", \\\\\\\"novel\\\\\\\");\\\\n            clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, type),\\\\n        col_type: \\\\\\\"text_3\\\\\\\",\\\\n    });\\\\n    layout.push({\\\\n        title: type === \\\\\\\"txt\\\\\\\" ? \\\\\\\"◉整本小说\\\\\\\" : \\\\\\\"○整本小说\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((type) => {\\\\n            if (type === \\\\\\\"txt\\\\\\\") return \\\\\\\"hiker://page/NovelCollected.view#noRecordHistory##noHistory#\\\\\\\";\\\\n            putMyVar(\\\\\\\".type\\\\\\\", \\\\\\\"txt\\\\\\\");\\\\n            setItem(\\\\\\\"main:type\\\\\\\", \\\\\\\"txt\\\\\\\");\\\\n            clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, type),\\\\n        col_type: \\\\\\\"text_3\\\\\\\"\\\\n    });\\\\n    if (type === \\\\\\\"txt\\\\\\\") {\\\\n        let txtView = $.require(\\\\\\\"hiker://page/externalimportTxt.view\\\\\\\");\\\\n        return txtView(layout);\\\\n    }\\\\n    let tag = File.getFilePath(Config[type + \\\\\\\"Path\\\\\\\"], \\\\\\\"dir\\\\\\\");\\\\n    if (tag.length === 0) {\\\\n        layout.push({\\\\n            col_type: \\\\\\\"line_blank\\\\\\\",\\\\n        });\\\\n        layout.push({\\\\n            title: \\\\\\\"设置\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\\\\\",\\\\n            col_type: \\\\\\\"text_2\\\\\\\",\\\\n            extra: {\\\\n                version: MY_RULE.version\\\\n            }\\\\n        });\\\\n\\\\n        layout.push({\\\\n            title: \\\\\\\"““帮助””\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/help.view#noRefresh##noRecordHistory##noHistory#?keyword=novelComic\\\\\\\",\\\\n            col_type: \\\\\\\"text_2\\\\\\\"\\\\n        });\\\\n        layout.push({\\\\n            title: '<h1 style=\\\\\\\"text-align: center;\\\\\\\">啥都没有耶</h1>',\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\n        });\\\\n        return setResult(layout);\\\\n    }\\\\n    layout.push({\\\\n        url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n        desc: \\\\\\\"搜你想要的#\\\\\\\" + type + \\\\\\\"#......\\\\\\\",\\\\n        title: \\\\\\\"🔍\\\\\\\",\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            rules: $.toString((tag, type) => {\\\\n                let arr1 = [];\\\\n                for (let i = 0; i < tag.length; i++) {\\\\n                    arr1.push({\\\\n                        \\\\\\\"title\\\\\\\": tag[i].name,\\\\n                        \\\\\\\"search_url\\\\\\\": \\\\\\\"hiker://empty?isAll=1&searchTerms=**&type=\\\\\\\" + type,\\\\n                        \\\\\\\"searchFind\\\\\\\": \\\\\\\"js:$.require('hiker://page/Search.view?rule='+MY_RULE._title);\\\\\\\"\\\\n                    });\\\\n                }\\\\n\\\\n                return JSON.stringify(arr1);\\\\n            }, tag, type),\\\\n            defaultValue: getMyVar('searchKey', ''),\\\\n            onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n        }\\\\n    });\\\\n\\\\n    layout.push({\\\\n        title: \\\\\\\"‘‘⚙设置’’\\\\\\\",\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\\\\\",\\\\n        extra: {\\\\n            version: MY_RULE.version\\\\n        }\\\\n    });\\\\n\\\\n\\\\n    for (let i in tag) {\\\\n        let it = tag[i];\\\\n        if (tgnum === i) {\\\\n            layout.push({\\\\n                title: \\\\\\\"““\\\\\\\" + it.name + \\\\\\\"””\\\\\\\",\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $([\\\\\\\"删除该目录\\\\\\\", \\\\\\\"跳转小程序\\\\\\\", \\\\\\\"打开书架\\\\\\\"], 1, \\\\\\\"选择操作\\\\\\\").select((it, type) => {\\\\n                    if (\\\\\\\"跳转小程序\\\\\\\" === input) {\\\\n                        return \\\\\\\"hiker://home@\\\\\\\" + it.name;\\\\n                    } else if(\\\\\\\"删除该目录\\\\\\\"===input){\\\\n                        //return then([\\\\\\\"该操作不会删除小程序，但该小程序下载的所有漫画将被删除\\\\\\\"]);\\\\n                        return $(\\\\\\\"该操作不会删除小程序，但该小程序下载的所有 漫画/小说 将被删除\\\\\\\").confirm((path) => {\\\\n                            const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                            if (File.deleteFiles(path)) {\\\\n                                clearMyVar(\\\\\\\".tgnum\\\\\\\");\\\\n                                refreshPage();\\\\n                                return \\\\\\\"toast://删除成功\\\\\\\";\\\\n                            } else {\\\\n                                return \\\\\\\"toast://删除失败\\\\\\\";\\\\n                            }\\\\n                        }, it.path);\\\\n                    }else{\\\\n                        return \\\\\\\"hiker://page/Bookrack.view?rule=本地资源管理&ruleName=\\\\\\\"+it.name+\\\\\\\"&type=\\\\\\\"+type;\\\\n                    }\\\\n                }, it, type)\\\\n            });\\\\n        } else {\\\\n            layout.push({\\\\n                title: it.name,\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(i => {\\\\n                    putMyVar(\\\\\\\".tgnum\\\\\\\", i);\\\\n                    refreshPage();\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }, i),\\\\n            });\\\\n        }\\\\n    }\\\\n    let path = tag[tgnum].path;\\\\n    let mhlist = File.getFilePath(path, \\\\\\\"dir\\\\\\\");\\\\n\\\\n    if (mhlist.length === 0) {\\\\n        layout.push({\\\\n            title: \\\\\\\"““””\\\\\\\" + \\\\\\\"啥都没有耶\\\\\\\".big(),\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        });\\\\n        return setResult(layout);\\\\n    }\\\\n    let pageUrl = type === \\\\\\\"novel\\\\\\\" ? \\\\\\\"hiker://page/NovelBrowser.view\\\\\\\" : \\\\\\\"hiker://page/ComicBrowser.view\\\\\\\";\\\\n    for (let item of mhlist) {\\\\n        let pic = fileExist(\\\\\\\"file://\\\\\\\" + item.path + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\".jpg\\\\\\\") ? item.path + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\".jpg\\\\\\\" : Config.def_Pic;\\\\n        let names=String(item.name).split(\\\\\\\"$\\\\\\\");\\\\n        layout.push({\\\\n            title: names[0],\\\\n            desc: names[1],\\\\n            pic_url: pic,\\\\n            url: type === \\\\\\\"novel\\\\\\\" ?pageUrl + \\\\\\\"?rule=\\\\\\\" + MY_RULE.title:$(\\\\\\\"#noLoading#\\\\\\\").lazyRule((pageUrl, path)=>{\\\\n                return $.require(\\\\\\\"longPress.js\\\\\\\").singleEnter(pageUrl, path);\\\\n            }, pageUrl, item.path),\\\\n            extra: Object.assign(item, {\\\\n                longClick: [{\\\\n                    title: \\\\\\\"删除\\\\\\\",\\\\n                    js: $.toString((path) => {\\\\n                        return $.require(\\\\\\\"longPress.js\\\\\\\").deleteFileForBook(path)\\\\n                    }, item.path)\\\\n                }],\\\\n                id: item.path\\\\n            })\\\\n        });\\\\n    }\\\\n    setResult(layout);\\\\n}\\\\n\\\\nmain();\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.漫画章节列表\\\",\\\"path\\\":\\\"ComicBrowser.view\\\",\\\"rule\\\":\\\"js:\\\\nconst Tool = $.require(\\\\\\\"Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"Config.js\\\\\\\");\\\\nconst File = $.require(\\\\\\\"File.js\\\\\\\");\\\\nif (getParam(\\\\\\\"hasParams\\\\\\\") === \\\\\\\"true\\\\\\\") {\\\\n    MY_PARAMS = {\\\\n        path: decodeURIComponent(getParam(\\\\\\\"path\\\\\\\")),\\\\n        name: decodeURIComponent(getParam(\\\\\\\"name\\\\\\\")),\\\\n        bookName: decodeURIComponent(getParam(\\\\\\\"bookName\\\\\\\")),\\\\n        ruleName: decodeURIComponent(getParam(\\\\\\\"ruleName\\\\\\\")),\\\\n        comicStyle: getParam(\\\\\\\"comicStyle\\\\\\\")\\\\n    }\\\\n}\\\\nlet path = MY_PARAMS.path;\\\\nif (!path) {\\\\n    path = Config.comicPath + \\\\\\\"/\\\\\\\" + MY_PARAMS.ruleName + \\\\\\\"/\\\\\\\" + MY_PARAMS.bookName;\\\\n}\\\\nif (MY_PARAMS.comicStyle) {\\\\n    Config.def_Comic_Style = MY_PARAMS.comicStyle;\\\\n}\\\\nsetPageTitle(\\\\\\\"CV|\\\\\\\" + (MY_PARAMS.name || File.getName(path)));\\\\n\\\\nvar layout = [];\\\\nlet mode = getMyVar(\\\\\\\".mode\\\\\\\", \\\\\\\"0\\\\\\\");\\\\nlet isReverse = getMyVar(\\\\\\\".isReverse\\\\\\\", \\\\\\\"0\\\\\\\");\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\".mode\\\\\\\");\\\\n    clearMyVar(\\\\\\\".isReverse\\\\\\\");\\\\n}));\\\\nconst comicStatus = new Map([\\\\n    [\\\\\\\"A\\\\\\\", \\\\\\\"\\\\\\\"],\\\\n    [\\\\\\\"B\\\\\\\", \\\\\\\"‘‘[未完成]’’\\\\\\\"]\\\\n]);\\\\n\\\\nfunction getTitle(title) {\\\\n    let titles = Tool.split(title, \\\\\\\"$\\\\\\\", 2);\\\\n    return comicStatus.get(titles[1]) + titles[2] || title;\\\\n}\\\\n\\\\nfunction getTitle2(title) {\\\\n    let titles = Tool.split(title, \\\\\\\"$\\\\\\\", 2);\\\\n    return titles[2] || title;\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"删除整本\\\\\\\",\\\\n    url: $(\\\\\\\"确认删除整本漫画？\\\\\\\").confirm((path) => {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        if (File.deleteFiles(path)) {\\\\n            back();\\\\n            return \\\\\\\"toast://删除成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://删除失败\\\\\\\";\\\\n        }\\\\n    }, path),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: [\\\\\\\"看漫画\\\\\\\", \\\\\\\"删除章节\\\\\\\"][mode],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((mode) => {\\\\n        putMyVar(\\\\\\\".mode\\\\\\\", mode === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, mode),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n})\\\\nlet mhlist = File.getFilePath(path, \\\\\\\"dir\\\\\\\");\\\\nmhlist.sort((a, b) => {\\\\n    a = (a.name.match(/\\\\\\\\d+/) || [])[0] || 0;\\\\n    b = (b.name.match(/\\\\\\\\d+/) || [])[0] || 0;\\\\n    return a - b;\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"““””\\\\\\\" + \\\\\\\"章节 \\\\\\\".big() + (\\\\\\\"共有:\\\\\\\" + mhlist.length + \\\\\\\"章\\\\\\\").small(),\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isReverse) => {\\\\n        putMyVar(\\\\\\\".isReverse\\\\\\\", isReverse === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, isReverse),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlet array = [];\\\\n\\\\nif (mode === \\\\\\\"0\\\\\\\") {\\\\n    if (Config.def_isComicCompatible === \\\\\\\"0\\\\\\\") {\\\\n        let lazy = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n            const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n            let filelist = File.getFilePath(input);\\\\n            let shorten = input.replace(getPath(\\\\\\\"hiker://files/\\\\\\\").slice(7), \\\\\\\"hiker://files/\\\\\\\");\\\\n            let piclist = filelist.map((item, i) => shorten + \\\\\\\"/\\\\\\\" + (i + 1) + \\\\\\\".jpg\\\\\\\");\\\\n            return \\\\\\\"pics://\\\\\\\" + piclist.join(\\\\\\\"&&\\\\\\\");\\\\n        });\\\\n        for (let item of mhlist) {\\\\n            let title = getTitle(item.name);\\\\n            array.push({\\\\n                title: title,\\\\n                url: item.path + lazy,\\\\n                col_type: Config.def_Comic_Style,\\\\n                pic_url: item.path + \\\\\\\"/1.jpg\\\\\\\"\\\\n            });\\\\n        }\\\\n    } else {\\\\n        for (let item of mhlist) {\\\\n            let title = getTitle(item.name);\\\\n            array.push({\\\\n                title: title,\\\\n                url: \\\\\\\"hiker://page/comicCompatible.view#autoPage##readTheme#?path=\\\\\\\" + encodeURIComponent(item.path),\\\\n                col_type: Config.def_Comic_Style,\\\\n                pic_url: item.path + \\\\\\\"/1.jpg\\\\\\\",\\\\n                extra: {\\\\n                    path: item.path,\\\\n                    title: getTitle2(item.name)\\\\n                }\\\\n            });\\\\n        }\\\\n    }\\\\n\\\\n} else {\\\\n    for (let item of mhlist) {\\\\n        let name = getTitle2(item.name);\\\\n        array.push({\\\\n            title: name,\\\\n            url: $(\\\\\\\"确认删除[\\\\\\\" + name + \\\\\\\"]？\\\\\\\").confirm((path) => {\\\\n                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                if (File.deleteFiles(path)) {\\\\n                    refreshPage(true);\\\\n                    return \\\\\\\"toast://删除成功\\\\\\\";\\\\n                } else {\\\\n                    return \\\\\\\"toast://删除失败\\\\\\\";\\\\n                }\\\\n            }, item.path),\\\\n            col_type: Config.def_Comic_Style,\\\\n            pic_url: item.path + \\\\\\\"/1.jpg\\\\\\\"\\\\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.js?rule=\\\\\\\" + MY_RULE._title);\\\\nlet comicRuleDirs = File.getFilePath(Config[getParam(\\\\\\\"type\\\\\\\") + \\\\\\\"Path\\\\\\\"], \\\\\\\"dir\\\\\\\");\\\\nif (getParam(\\\\\\\"isAll\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n    comicRuleDirs = comicRuleDirs.filter(item => item.name === MY_RULE.title);\\\\n}\\\\n\\\\nlet searchResult = [];\\\\nlet searchTerms= getParam(\\\\\\\"searchTerms\\\\\\\");\\\\nlet searchTest;\\\\n\\\\nif (!getSearchMode()) {\\\\n    let termsArr = searchTerms.split(\\\\\\\"\\\\\\\").map(t => t.replace(/\\\\\\\\*|\\\\\\\\.|\\\\\\\\?|\\\\\\\\+|\\\\\\\\$|\\\\\\\\^|\\\\\\\\[|\\\\\\\\]|\\\\\\\\(|\\\\\\\\)|\\\\\\\\{|\\\\\\\\}|\\\\\\\\||\\\\\\\\/|\\\\\\\\\\\\\\\\/g, k => \\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\" + k));\\\\n    let reg = new RegExp(termsArr.join(\\\\\\\".*\\\\\\\"), \\\\\\\"i\\\\\\\");\\\\n    searchTest = text => reg.test(text);\\\\n} else {\\\\n    searchTest = text => searchContains(text, searchTerms, false);\\\\n}\\\\n\\\\nlet pageUrl = getParam(\\\\\\\"type\\\\\\\") === \\\\\\\"novel\\\\\\\" ? \\\\\\\"hiker://page/NovelBrowser.view\\\\\\\" : \\\\\\\"hiker://page/ComicBrowser.view\\\\\\\";\\\\nfor (let sonDir of comicRuleDirs) {\\\\n    let comicList = File.getFilePath(sonDir.path, \\\\\\\"dir\\\\\\\");\\\\n    for (let comic of comicList) {\\\\n        if (searchTest(comic.name)) {\\\\n            searchResult.push({\\\\n                title: comic.name,\\\\n                pic_url: comic.path + \\\\\\\"/\\\\\\\" + comic.name + \\\\\\\".jpg\\\\\\\",\\\\n                url: pageUrl + \\\\\\\"?rule=\\\\\\\" + MY_RULE._title,\\\\n                desc: sonDir.name,\\\\n                extra: comic\\\\n            });\\\\n        }\\\\n    }\\\\n\\\\n}\\\\nsetResult(searchResult);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.设置\\\",\\\"path\\\":\\\"Setting.view\\\",\\\"rule\\\":\\\"js:\\\\nsetPageTitle(MY_RULE.title + \\\\\\\"|设置\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\n\\\\nlet layout = [];\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>基础设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"目录路径\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRefresh##noRecordHistory##noHistory#?settingType=contents\\\\\\\",\\\\n    desc: Config.homePath,\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"设置默认封面\\\\\\\",\\\\n    desc: Config.def_Pic,\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRefresh##noRecordHistory##noHistory#?settingType=defaultPic\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>下载器设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\n\\\\nfunction setNum(key, test) {\\\\n    let Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\", 0) || \\\\\\\"{}\\\\\\\");\\\\n    input = parseInt(input);\\\\n    if (Number.isNaN(input)) return \\\\\\\"toast://请输入数字\\\\\\\";\\\\n    if (!test(input)) return \\\\\\\"toast://不符合条件\\\\\\\";\\\\n    Config[key] = input;\\\\n    saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config), 0);\\\\n    refreshPage(false);\\\\n    return \\\\\\\"toast://修改成功\\\\\\\";\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"log数\\\\\\\",\\\\n    url: $(Config.logNum, \\\\\\\"0<N<100\\\\\\\").input(setNum, \\\\\\\"logNum\\\\\\\", it => it > 0 && it < 100),\\\\n    desc: \\\\\\\"\\\\\\\" + Config.logNum,\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"分批下载数(0不开启)\\\\\\\",\\\\n    url: $(\\\\\\\"\\\\\\\" + Config.threadNum, \\\\\\\"N>-1\\\\\\\").input(setNum, \\\\\\\"threadNum\\\\\\\", it => it > -1),\\\\n    desc: \\\\\\\"\\\\\\\" + Config.threadNum,\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false,\\\\n    }\\\\n});\\\\n\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>小说阅读器设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"默认开启分页阅读\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((def_isPaginate) => {\\\\n        let Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\", 0) || \\\\\\\"{}\\\\\\\");\\\\n\\\\n        Config.def_isPaginate = def_isPaginate === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\";\\\\n\\\\n        saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config), 0);\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, Config.def_isPaginate),\\\\n    desc: Config.def_isPaginate === \\\\\\\"0\\\\\\\" ? \\\\\\\"不开启\\\\\\\" : \\\\\\\"开启\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"每页最大章数\\\\\\\",\\\\n    url: $(Config.viewPageSize, \\\\\\\"30<N<500\\\\\\\").input(setNum, \\\\\\\"viewPageSize\\\\\\\", it => it > 30 && it < 500),\\\\n    desc: \\\\\\\"\\\\\\\" + Config.viewPageSize,\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"替换规则\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRecordHistory##noHistory##noRefresh#?settingType=replaceRule\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>漫画阅读器设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"兼容模式\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((def_isComicCompatible) => {\\\\n        let Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\", 0) || \\\\\\\"{}\\\\\\\");\\\\n\\\\n        Config.def_isComicCompatible = def_isComicCompatible === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\";\\\\n\\\\n        saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config), 0);\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, Config.def_isComicCompatible),\\\\n    desc: Config.def_isComicCompatible === \\\\\\\"0\\\\\\\" ? \\\\\\\"不开启\\\\\\\" : \\\\\\\"开启\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"漫画列表样式\\\\\\\",\\\\n    url: $([\\\\\\\"text_1\\\\\\\", \\\\\\\"avatar\\\\\\\", \\\\\\\"pic_3\\\\\\\", \\\\\\\"pic_3_square\\\\\\\", \\\\\\\"movie_3_marquee\\\\\\\"], 1, \\\\\\\"请选择漫画列表显示样式\\\\\\\").select(() => {\\\\n        let Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\", 0) || \\\\\\\"{}\\\\\\\");\\\\n        Config.def_Comic_Style = input;\\\\n        saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config), 0);\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, Config.def_Comic_Style),\\\\n    desc: Config.def_Comic_Style||\\\\\\\"\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"<strong>其他设置</strong>\\\\\\\".big(),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"规则发布页\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\\\\\",\\\\n    extra: {\\\\n        lver: MY_PARAMS.version || \\\\\\\"获取版本失败，自行查看\\\\\\\",\\\\n        id: \\\\\\\"3559\\\\\\\"\\\\n    },\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"恢复默认设置\\\\\\\",\\\\n    url: $(\\\\\\\"确认恢复默认设置？\\\\\\\").confirm(() => {\\\\n        deleteFile(\\\\\\\"config.json\\\\\\\");\\\\n        refreshPage(false);\\\\n        return \\\\\\\"toast://恢复完成\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"清理缓存\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRecordHistory##noHistory#?settingType=cache\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"文件管理\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/FileManagement.view#noRefresh##noRecordHistory##noHistory#\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlet tid = Date.now();\\\\nlayout.push({\\\\n    title: \\\\\\\"检测更新\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((oldVersion, tid) => {\\\\n        try {\\\\n            let newVersion = JSON.parse(request(\\\\\\\"http://hiker.nokia.press/hikerule/dev/getbyid?id=3559\\\\\\\", {\\\\n                timeout: 2000\\\\n            })).result.ver;\\\\n            if (newVersion <= oldVersion) {\\\\n                updateItem(tid + \\\\\\\"#设置_更新\\\\\\\", {\\\\n                    title: \\\\\\\"已经是最新版本了\\\\\\\"\\\\n                });\\\\n                return \\\\\\\"toast://已经是最新版本了\\\\\\\";\\\\n            } else {\\\\n                updateItem(tid + \\\\\\\"#设置_更新\\\\\\\", {\\\\n                    title: \\\\\\\"有新版本还未更新\\\\\\\"\\\\n                });\\\\n                toast(\\\\\\\"有新版本还未更新\\\\\\\");\\\\n                return \\\\\\\"rule://5rW36ZiU6KeG55WM77+laG9tZV9ydWxlX3VybO+/pWh0dHA6Ly9oaWtlci5ub2tpYS5wcmVzcy9oaWtlcnVsZS9ydWxlbGlzdC5qc29uP2lkPTM1NTk=\\\\\\\";\\\\n            }\\\\n        } catch (e) {\\\\n            updateItem(tid + \\\\\\\"#设置_更新\\\\\\\", {\\\\n                title: \\\\\\\"信息获取失败\\\\\\\"\\\\n            });\\\\n            return \\\\\\\"toast://更新信息获取失败\\\\\\\";\\\\n        }\\\\n    }, MY_PARAMS.version, tid),\\\\n    extra: {\\\\n        id: tid + \\\\\\\"#设置_更新\\\\\\\"\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"关于如何调用\\\\\\\",\\\\n    url: \\\\\\\"mqqapi://forward/url?src_type=web&style=default&plg_auth=1&version=1&url_prefix=aHR0cHM6Ly9xdW4ucXEuY29tL3Fxd2ViL3F1bnByby9zaGFyZT9fd3Y9MyZfd3d2PTEyOCZpbnZpdGVDb2RlPTFIRnlCSiZmcm9tPTI0NjYxMCZiaXo9a2EjL291dA==\\\\\\\",\\\\n    desc: \\\\\\\"详细点击加入频道(快来华山与我论[ji]剑)\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"问题反馈\\\\\\\",\\\\n    url: \\\\\\\"mqqapi://forward/url?src_type=web&style=default&plg_auth=1&version=1&url_prefix=aHR0cHM6Ly9xdW4ucXEuY29tL3Fxd2ViL3F1bnByby9zaGFyZT9fd3Y9MyZfd3d2PTEyOCZhcHBDaGFubmVsPXNoYXJlJmludml0ZUNvZGU9MVhOYWxBRXl2VmomY29udGVudElEPWMzbElQJmJ1c2luZXNzVHlwZT0yJmZyb209MTgxMDc0JmJpej1rYSZtYWluU291cmNlSWQ9c2hhcmUmc3ViU291cmNlSWQ9b3RoZXJzJmp1bXBzb3VyY2U9c2hvcnR1cmw=&t=1671893123597#Intent;scheme=mqqapi;package=com.tencent.mobileqq;end\\\\\\\",\\\\n    desc: \\\\\\\"绝对不会有bug(啊我不接受!)\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n/*\\\\nlayout.push({\\\\n    title: \\\\\\\"清除小说分页记录\\\\\\\",\\\\n    url: $(\\\\\\\"确认清除小说分页记录？\\\\\\\").confirm(() => {\\\\n        deleteFile(\\\\\\\"novelFootprint.json\\\\\\\");\\\\n        return \\\\\\\"toast://清除完成\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\n*/\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.小说章节列表\\\",\\\"path\\\":\\\"NovelBrowser.view\\\",\\\"rule\\\":\\\"js:\\\\nif (getParam(\\\\\\\"hasParams\\\\\\\") === \\\\\\\"true\\\\\\\") {\\\\n    MY_PARAMS = {\\\\n        path: decodeURIComponent(getParam(\\\\\\\"path\\\\\\\")),\\\\n        name: decodeURIComponent(getParam(\\\\\\\"name\\\\\\\"))\\\\n    }\\\\n}\\\\nlet path = MY_PARAMS.path;\\\\nsetPageTitle(\\\\\\\"NV|\\\\\\\" + MY_PARAMS.name);\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\nconst bookInfo = Object.assign({\\\\n    foot: 0,\\\\n    isReplace: true,\\\\n    isSegment: 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.js\\\\\\\");\\\\n\\\\n    let filelist = File.getFilePath(paths.path, \\\\\\\"file\\\\\\\", \\\\\\\".txt\\\\\\\");\\\\n    let listLength = filelist.length;\\\\n    if (listLength === 0) {\\\\n        hideLoading();\\\\n        return \\\\\\\"toast://空的章节\\\\\\\";\\\\n    }\\\\n    const bookInfo = Object.assign({\\\\n        selected: [],\\\\n        isReplace: true\\\\n    }, JSON.parse(request(\\\\\\\"file://\\\\\\\" + paths.path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\"));\\\\n    let bufilelist = [];\\\\n    for (let i = 0; i < listLength; i++) {\\\\n        let file = filelist[i];\\\\n        let fileInfo = Tool.split(file.name, \\\\\\\"$\\\\\\\", 2);\\\\n        bufilelist.push({\\\\n            name: fileInfo[2].slice(0, fileInfo[2].lastIndexOf(\\\\\\\".\\\\\\\")),\\\\n            path: \\\\\\\"file://\\\\\\\" + file.path,\\\\n            id: Number(fileInfo[0]) || 0\\\\n        });\\\\n    }\\\\n    bufilelist.sort((a, b) => a.id - b.id);\\\\n    let entirePath = paths.path.replace(Config.novelPath, Config.novelFullPath) + \\\\\\\".txt\\\\\\\";\\\\n    let entirePathto = bookInfo.isReplace ? entirePath + \\\\\\\".tmp\\\\\\\" : entirePath;\\\\n\\\\n    if (fileExist(\\\\\\\"file://\\\\\\\" + entirePath)) {\\\\n        toast(\\\\\\\"初始化文件\\\\\\\");\\\\n        if (!File.deleteFiles(entirePath)) {\\\\n            hideLoading();\\\\n            return \\\\\\\"toast://初始化失败\\\\\\\";\\\\n        } else {\\\\n            toast(\\\\\\\"初始化成功\\\\\\\");\\\\n        }\\\\n    }\\\\n\\\\n    for (let i = 0; i < listLength; i++) {\\\\n        let item = bufilelist[i];\\\\n        let content = request(item.path);\\\\n        File.fileWriteAppend(entirePathto, item.name + \\\\\\\"\\\\\\\\n　　\\\\\\\" + content.replace(/&nbsp;/g,\\\\\\\"\\\\\\\").split(/(\\\\\\\\n|\\\\\\\\r)+/).filter(it => it.trim().length > 1).map(it=>it.trim()).join(\\\\\\\"\\\\\\\\r　　\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\\n\\\\\\\");\\\\n    }\\\\n    if (bookInfo.isReplace) {\\\\n        let ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        let len = ruleList.length;\\\\n        let replacePattern = [\\\\\\\"replace\\\\\\\", \\\\\\\"replaceAll\\\\\\\"];\\\\n        let flag = File.fileRule(entirePathto, entirePath, (javaString) => {\\\\n            for (let i = 0; i < len; i++) {\\\\n                let replaceRule = ruleList[i];\\\\n                if (!bookInfo.selected.includes(replaceRule.id)) {\\\\n                    continue;\\\\n                }\\\\n                let replace = replacePattern[0 + replaceRule.isRegex];\\\\n                javaString = javaString[replace](replaceRule.pattern, replaceRule.replacement);\\\\n            }\\\\n            return javaString.getBytes();\\\\n        });\\\\n        if (!flag) {\\\\n            hideLoading();\\\\n            return \\\\\\\"toast://合并失败\\\\\\\";\\\\n        }\\\\n\\\\n    }\\\\n    hideLoading();\\\\n    return \\\\\\\"toast://合并完成\\\\\\\";\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"合并小说\\\\\\\",\\\\n    url: $(\\\\\\\"确定合并?\\\\\\\\n会覆盖已有TXT\\\\\\\").confirm(txt, MY_PARAMS),\\\\n    col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: [\\\\\\\"☐分页\\\\\\\", \\\\\\\"☑分页\\\\\\\"][mode2],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((mode2) => {\\\\n        putMyVar(\\\\\\\".mode2\\\\\\\", mode2 === \\\\\\\"0\\\\\\\" ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, mode2),\\\\n    col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: [\\\\\\\"☐分段\\\\\\\", \\\\\\\"☑分段\\\\\\\"][Number(bookInfo.isSegment)],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((isSegment, path) => {\\\\n        const bookInfo = JSON.parse(request(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n        bookInfo.isSegment = !isSegment;\\\\n        writeFile(\\\\\\\"file://\\\\\\\" + path+\\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, bookInfo.isSegment, path),\\\\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.js\\\\\\\");\\\\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: false,\\\\n    isSegment: 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}\\\\nif (bookInfo.isSegment) {\\\\n    content = \\\\\\\"　　\\\\\\\" + content.split(/(\\\\\\\\n|\\\\\\\\r)+/).filter(it => it.trim().length > 1).map(it => it.trim()).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.js\\\\\\\");\\\\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.js\\\\\\\");\\\\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        }else{\\\\n            layout.push({\\\\n                title: \\\\\\\"图片late\\\\\\\",\\\\n                col_type: \\\\\\\"movie_3\\\\\\\",\\\\n                pic_url: \\\\\\\"hiker://images/home_late\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(setDefaultPic, \\\\\\\"hiker://images/home_late\\\\\\\")\\\\n            });\\\\n        }\\\\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                        fileType: \\\\\\\".jpg|.jpeg|.gif|.png|.svg|.bmp\\\\\\\",\\\\n                        onClickType: \\\\\\\"confirm\\\\\\\",\\\\n                        store: \\\\\\\"selectPathCache2\\\\\\\",\\\\n                        memoryPath: true\\\\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 = [];\\\\n        try {\\\\n            ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        } catch (e) {\\\\n            confirm({\\\\n                title: '错误提示',\\\\n                content: '替换数据读取失败，是否初始化？\\\\\\\\n该操作会清除你的替换数据!!!',\\\\n                confirm: $.toString(() => {\\\\n                    deleteFile(\\\\\\\"replaceRule.json\\\\\\\");\\\\n                    toast(\\\\\\\"初始化完成\\\\\\\");\\\\n                }),\\\\n                cancel: $.toString(() => {\\\\n                    //toast(\\\\\\\"取消\\\\\\\");\\\\n                })\\\\n            })\\\\n        }\\\\n        layout.push({\\\\n            title: \\\\\\\"新建替换\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/editReplaceRule.view#noRecordHistory##noHistory##noRefresh#?isNew=true\\\\\\\",\\\\n            col_type: \\\\\\\"text_3\\\\\\\"\\\\n        });\\\\n        layout.push({\\\\n            title: \\\\\\\"导出规则\\\\\\\",\\\\n            url: $(\\\\\\\"确认导出\\\\\\\" + ruleList.length + \\\\\\\"条规则？\\\\\\\\n({homePtah}/replaceRule.json)\\\\\\\").confirm((num) => {\\\\n                const Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\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.js\\\\\\\");\\\\n                if (input.startsWith(\\\\\\\"hiker://files/\\\\\\\")) input = getPath(input).slice(7);\\\\n                if (input.endsWith(\\\\\\\"/\\\\\\\")) input = input.replace(/\\\\\\\\/$/, \\\\\\\"\\\\\\\");\\\\n                if (Config.homePath == input) return \\\\\\\"toast://已经是当前目录\\\\\\\";\\\\n                Config = JSON.parse(readFile(\\\\\\\"config.json\\\\\\\", 0) || \\\\\\\"{}\\\\\\\");\\\\n                Config.homePath = input;\\\\n                saveFile(\\\\\\\"config.json\\\\\\\", JSON.stringify(Config), 0);\\\\n                back();\\\\n                return \\\\\\\"toast://已保存\\\\\\\";\\\\n            }, id),\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        });\\\\n\\\\n        break;\\\\n}\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.编辑替换规则\\\",\\\"path\\\":\\\"editReplaceRule.view\\\",\\\"rule\\\":\\\"js:\\\\nconst isNew = MY_PARAMS.isNew || getParam(\\\\\\\"isNew\\\\\\\");\\\\nconst index = MY_PARAMS.index || Number(getParam(\\\\\\\"index\\\\\\\"));\\\\nlet layout = [];\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\".editReplaceRule.name\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\");\\\\n    clearMyVar(\\\\\\\".editReplaceRule.first\\\\\\\");\\\\n    //clearMyVar(\\\\\\\".editReplaceRule.scope\\\\\\\");\\\\n}));\\\\nlet ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\nlet id = \\\\\\\"#\\\\\\\" + new Date().getTime();\\\\n//let replaceRule = isNew == \\\\\\\"true\\\\\\\"?{}:ruleList[index];\\\\nif (isNew == \\\\\\\"true\\\\\\\") {\\\\n    replaceRule = {\\\\n        id: new Date().getTime(),\\\\n        isRegex: false,\\\\n    }\\\\n} else {\\\\n    replaceRule = ruleList[index];\\\\n}\\\\n//首次初始化\\\\nif(getMyVar(\\\\\\\".editReplaceRule.first\\\\\\\",\\\\\\\"\\\\\\\")==\\\\\\\"\\\\\\\"){\\\\n    putMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\", \\\\\\\"\\\\\\\" + replaceRule.isRegex);\\\\n    putMyVar(\\\\\\\".editReplaceRule.first\\\\\\\",\\\\\\\"1\\\\\\\");\\\\n}\\\\nlayout.push({\\\\n    title: \\\\\\\"拷贝\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n        let att = [\\\\\\\"name\\\\\\\", \\\\\\\"isRegex\\\\\\\", \\\\\\\"pattern\\\\\\\", \\\\\\\"replacement\\\\\\\"];\\\\n        let json = {};\\\\n        att.forEach(key => {\\\\n            let value = getMyVar(\\\\\\\".editReplaceRule.\\\\\\\" + key, \\\\\\\"\\\\\\\");\\\\n            if (key === \\\\\\\"isRegex\\\\\\\") {\\\\n                value = value === \\\\\\\"true\\\\\\\" ? true : false;\\\\n            }\\\\n            json[key] = value;\\\\n        });\\\\n        copy(JSON.stringify(json));\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"粘贴\\\\\\\",\\\\n    url: $(\\\\\\\"{{clipboard}}\\\\\\\").input(() => {\\\\n        try {\\\\n            let json = JSON.parse(input);\\\\n            if (Array.isArray(json) || json.pattern == undefined) return;\\\\n            let att = [\\\\\\\"name\\\\\\\", \\\\\\\"isRegex\\\\\\\", \\\\\\\"pattern\\\\\\\", \\\\\\\"replacement\\\\\\\"];\\\\n            att.forEach(key => {\\\\n                putMyVar(\\\\\\\".editReplaceRule.\\\\\\\" + key, String(json[key]));\\\\n            });\\\\n            refreshPage(false);\\\\n        } catch (e) {\\\\n            log(e.toString());\\\\n        }\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换规则名称\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        defaultValue: getMyVar(\\\\\\\".editReplaceRule.name\\\\\\\", replaceRule.name),\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.name\\\\\\\",input);'\\\\n    }\\\\n});\\\\n\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换规则\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height: -1,\\\\n        defaultValue: getMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\", replaceRule.pattern),\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\", input);'\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"是否使用正则表达式：\\\\\\\" + getMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\"),\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((id) => {\\\\n        let isRegex = getMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\") === \\\\\\\"true\\\\\\\" ? false : true;\\\\n        updateItem({\\\\n            extra: {\\\\n                id: id\\\\n            },\\\\n            title: \\\\\\\"是否使用正则表达式：\\\\\\\" + isRegex\\\\n        });\\\\n        putMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\", \\\\\\\"\\\\\\\" + isRegex);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, id),\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        id: id\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换为\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height: -1,\\\\n        defaultValue: getMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\", replaceRule.replacement),\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\",input);'\\\\n    }\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"保存\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((replaceRule, isNew, index) => {\\\\n        let pattern = getMyVar(\\\\\\\".editReplaceRule.pattern\\\\\\\", \\\\\\\"\\\\\\\");\\\\n        if (!pattern) {\\\\n            return \\\\\\\"toast://替换规则不能为空\\\\\\\";\\\\n        }\\\\n        Object.assign(replaceRule, {\\\\n            name: getMyVar(\\\\\\\".editReplaceRule.name\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n            isRegex: getMyVar(\\\\\\\".editReplaceRule.isRegex\\\\\\\") === \\\\\\\"true\\\\\\\" ? true : false,\\\\n            pattern: pattern,\\\\n            replacement: getMyVar(\\\\\\\".editReplaceRule.replacement\\\\\\\", \\\\\\\"\\\\\\\")\\\\n        });\\\\n        let ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\n        if (isNew == \\\\\\\"true\\\\\\\") {\\\\n            ruleList.push(replaceRule);\\\\n        } else {\\\\n            ruleList.splice(index, 1, replaceRule);\\\\n        }\\\\n        saveFile(\\\\\\\"replaceRule.json\\\\\\\", JSON.stringify(ruleList));\\\\n        back();\\\\n        return \\\\\\\"toast://保存成功\\\\\\\";\\\\n    }, replaceRule, isNew, index),\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n});\\\\n\\\\n/*\\\\nlayout.push({\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"替换范围\\\\\\\",\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height: -1,\\\\n        defaultValue: \\\\\\\"\\\\\\\",\\\\n        onChange: 'putMyVar(\\\\\\\".editReplaceRule.scope\\\\\\\",input);'\\\\n    }\\\\n});\\\\n\\\\n*/\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.小说个性化净化\\\",\\\"path\\\":\\\"NovelCustom.view\\\",\\\"rule\\\":\\\"js:\\\\nsetPageTitle(\\\\\\\"替换规则|\\\\\\\" + MY_PARAMS.name);\\\\nlet ruleList = JSON.parse(readFile(\\\\\\\"replaceRule.json\\\\\\\") || \\\\\\\"[]\\\\\\\");\\\\nlet id = \\\\\\\"#\\\\\\\" + new Date().getTime();\\\\n\\\\nconst bookInfo = Object.assign({\\\\n    foot: 0,\\\\n    isReplace: true,\\\\n    selected: []\\\\n}, JSON.parse(request(\\\\\\\"file://\\\\\\\" + MY_PARAMS.path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\"));\\\\n\\\\nlet layout = [];\\\\nlayout.push({\\\\n    title: [\\\\\\\"☐净化\\\\\\\", \\\\\\\"☑净化\\\\\\\"][0 + bookInfo.isReplace],\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(($id, path) => {\\\\n\\\\n        var bookInfo = JSON.parse(request(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\");\\\\n        let isReplace = bookInfo.isReplace===undefined?true:bookInfo.isReplace;\\\\n        bookInfo.isReplace = !isReplace;\\\\n        writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n        updateItem($id, {\\\\n            title: isReplace ? \\\\\\\"☐净化\\\\\\\" : \\\\\\\"☑净化\\\\\\\",\\\\n        });\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }, id + \\\\\\\"#-1\\\\\\\", MY_PARAMS.path),\\\\n    extra: {\\\\n        id: id + \\\\\\\"#-1\\\\\\\"\\\\n    },\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\nlayout.push({\\\\n    title: \\\\\\\"编辑规则\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Setting/More.view#noRecordHistory##noHistory##noRefresh#?settingType=replaceRule\\\\\\\",\\\\n    col_type: \\\\\\\"text_2\\\\\\\",\\\\n    extra:{\\\\n        isRefresh: true\\\\n    }\\\\n});\\\\nfor (let i = 0, len = ruleList.length; i < len; i++) {\\\\n    let replaceRule = ruleList[i];\\\\n    let isTrue = bookInfo.selected.includes(replaceRule.id);\\\\n    layout.push({\\\\n        title: (isTrue ? \\\\\\\"●\\\\\\\" : \\\\\\\"○\\\\\\\") + replaceRule.name,\\\\n        col_type: \\\\\\\"text_1\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        y: 0,\\\\n        extra: {\\\\n            isTrue: isTrue,\\\\n            id: id + i,\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"开启\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(($id, replaceRule, path) => {\\\\n            if (findItem($id).extra.isTrue) {\\\\n                return \\\\\\\"toast://已开启\\\\\\\";\\\\n            }\\\\n            const bookInfo = Object.assign({\\\\n                selected: []\\\\n            }, JSON.parse(request(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\"));\\\\n            bookInfo.selected.push(replaceRule.id);\\\\n            updateItem($id, {\\\\n                title: \\\\\\\"●\\\\\\\" + replaceRule.name,\\\\n                extra: {\\\\n                    isTrue: true,\\\\n                    id: $id,\\\\n                    lineVisible: false\\\\n                }\\\\n            });\\\\n            writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, id + i, replaceRule, MY_PARAMS.path),\\\\n        col_type: \\\\\\\"text_2\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"关闭\\\\\\\",\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(($id, replaceRule, path) => {\\\\n            if (!findItem($id).extra.isTrue) {\\\\n                return \\\\\\\"toast://已关闭\\\\\\\";\\\\n            }\\\\n            const bookInfo = Object.assign({\\\\n                selected: []\\\\n            }, JSON.parse(request(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\") || \\\\\\\"{}\\\\\\\"));\\\\n            bookInfo.selected.splice(bookInfo.selected.indexOf(replaceRule.id), 1);\\\\n            updateItem($id, {\\\\n                title: \\\\\\\"○\\\\\\\" + replaceRule.name,\\\\n                extra: {\\\\n                    isTrue: false,\\\\n                    id: $id,\\\\n                    lineVisible: false\\\\n                }\\\\n            });\\\\n            writeFile(\\\\\\\"file://\\\\\\\" + path + \\\\\\\"/bookInfo.json\\\\\\\", JSON.stringify(bookInfo));\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, id + i, replaceRule, MY_PARAMS.path),\\\\n        col_type: \\\\\\\"text_2\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n}\\\\n\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.外导小说\\\",\\\"path\\\":\\\"externalimportTxt.view\\\",\\\"rule\\\":\\\"js:\\\\nfunction txtView(layout) {\\\\n    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n    const Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\n    let files = File.getFilePath(Config.externalImportPath);\\\\n    files = files.filter(v => /(\\\\\\\\.txt|\\\\\\\\.epub)$/.test(v.name));\\\\n\\\\n    setPageTitle(\\\\\\\"小说书架\\\\\\\");\\\\n    //let layout = [];\\\\n    layout.push({\\\\n        url: 'input?\\\\\\\"hiker://page/txtSearch.view#noRefresh#?searchTerms=\\\\\\\"+encodeURIComponent(input):\\\\\\\"toast://请输入小说名\\\\\\\"',\\\\n        desc: \\\\\\\"搜索\\\\\\\",\\\\n        title: \\\\\\\"🔍\\\\\\\",\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            defaultValue: getMyVar(\\\\\\\"searchKeyByTxt\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n            onChange: \\\\\\\"putMyVar('searchKeyByTxt',input)\\\\\\\"\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"导入小说\\\\\\\",\\\\n        col_type: \\\\\\\"text_3\\\\\\\",\\\\n        url: $([\\\\\\\"系统选择器\\\\\\\", \\\\\\\"海阔选择器\\\\\\\"], 1, \\\\\\\"选择器类型\\\\\\\").select(() => {\\\\n            if (input === \\\\\\\"系统选择器\\\\\\\") {\\\\n                return \\\\\\\"fileSelect://\\\\\\\" + $.toString(() => {\\\\n                    if (!/(\\\\\\\\.txt|.epub)$/i.test(input)) {\\\\n                        toast(\\\\\\\"选择了错误的文件类型\\\\\\\");\\\\n                        return;\\\\n                    }\\\\n                    const Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\n                    let fileMatch = input.match(/\\\\\\\\/([^\\\\\\\\/]*?)(\\\\\\\\.txt|\\\\\\\\.epub)$/i);\\\\n                    let novelName = fileMatch[1].replace(\\\\\\\"_fileSelect_\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                    let topath = Config.externalImportPath + novelName + fileMatch[2];\\\\n                    let topathCache = Config.contentsCache + novelName + fileMatch[2];\\\\n                    let path = input.replace(\\\\\\\"file://\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                    if (fileExist(\\\\\\\"file://\\\\\\\" + topath)) {\\\\n                        confirm({\\\\n                            title: \\\\\\\"导入提示\\\\\\\",\\\\n                            content: \\\\\\\"已存在[\\\\\\\" + novelName + \\\\\\\"]是否覆盖?\\\\\\\",\\\\n                            confirm: $.toString((path, topath, topathCache) => {\\\\n                                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                                File.copyFile(path, topath, true);\\\\n                                if (fileExist(\\\\\\\"file://\\\\\\\" + topathCache)) {\\\\n                                    File.deleteFiles(topathCache);\\\\n                                }\\\\n                                refreshPage(false);\\\\n                                return \\\\\\\"toast://导入成功\\\\\\\";\\\\n                            }, path, topath, topathCache)\\\\n                        });\\\\n                        return;\\\\n                    } else {\\\\n                        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                        File.copyFile(path, topath);\\\\n                        if (fileExist(\\\\\\\"file://\\\\\\\" + topathCache)) {\\\\n                            File.deleteFiles(topathCache);\\\\n                        }\\\\n                        refreshPage(false);\\\\n                        toast(\\\\\\\"导入成功\\\\\\\");\\\\n                        return;\\\\n                    }\\\\n                });\\\\n            } else {\\\\n                let requireUrl = \\\\\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\\\\\";\\\\n                let fileSelect = $.require(requireUrl);\\\\n                return fileSelect.fileSelectionUri({\\\\n                    callback: $.toString(() => {\\\\n                        const Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\n                        let fileMatch = PATH.match(/\\\\\\\\/([^\\\\\\\\/]*?)(\\\\\\\\.txt|\\\\\\\\.epub)$/i);\\\\n                        let novelName = fileMatch[1];\\\\n                        let topath = Config.externalImportPath + novelName + fileMatch[2];\\\\n                        let topathCache = Config.contentsCache + novelName + fileMatch[2];\\\\n                        let path = PATH;\\\\n                        if (fileExist(\\\\\\\"file://\\\\\\\" + topath)) {\\\\n                            return $(\\\\\\\"已存在[\\\\\\\" + novelName + \\\\\\\"]是否覆盖?\\\\\\\").confirm((path, topath, topathCache) => {\\\\n                                const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                                File.copyFile(path, topath, true);\\\\n                                if (fileExist(\\\\\\\"file://\\\\\\\" + topathCache)) {\\\\n                                    File.deleteFiles(topathCache);\\\\n                                }\\\\n                                back();\\\\n                                return \\\\\\\"toast://导入成功\\\\\\\";\\\\n                            }, path, topath, topathCache);\\\\n                        } else {\\\\n                            const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                            File.copyFile(path, topath);\\\\n                            if (fileExist(\\\\\\\"file://\\\\\\\" + topathCache)) {\\\\n                                File.deleteFiles(topathCache);\\\\n                            }\\\\n                            back();\\\\n                            return \\\\\\\"toast://导入成功\\\\\\\";\\\\n                        }\\\\n                    }),\\\\n                    fileType: \\\\\\\".txt|.epub\\\\\\\",\\\\n                    onClickType: \\\\\\\"confirm\\\\\\\",\\\\n                    store: \\\\\\\"selectPathCache1\\\\\\\",\\\\n                    memoryPath: true\\\\n                });\\\\n            }\\\\n        }),\\\\n        extra: {\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n    let options = [\\\\\\\"阅读\\\\\\\", \\\\\\\"分享\\\\\\\", \\\\\\\"删除\\\\\\\", \\\\\\\"打开方式\\\\\\\"];\\\\n\\\\n    let pattern = getMyVar(\\\\\\\":txtPattern\\\\\\\", options[0]);\\\\n    let id = Date.now() + \\\\\\\":模式\\\\\\\";\\\\n    layout.push({\\\\n        title: pattern,\\\\n        col_type: \\\\\\\"text_3\\\\\\\",\\\\n        url: $(options, 1, \\\\\\\"操作模式\\\\\\\").select((id) => {\\\\n            putMyVar(\\\\\\\":txtPattern\\\\\\\", input);\\\\n            updateItem(id, {\\\\n                title: input\\\\n            });\\\\n        }, id),\\\\n        extra: {\\\\n            id: id\\\\n        }\\\\n    });\\\\n    layout.push({\\\\n        title: \\\\\\\"文件管理\\\\\\\",\\\\n        col_type: \\\\\\\"text_3\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/FileManagement.view#noRefresh##noRecordHistory##noHistory#?type=externalImportPath\\\\\\\"\\\\n    });\\\\n    layout.push({\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    });\\\\n\\\\n    function operation(path, name, type) {\\\\n        let pattern = getMyVar(\\\\\\\":txtPattern\\\\\\\", \\\\\\\"阅读\\\\\\\");\\\\n        switch (pattern) {\\\\n            case \\\\\\\"分享\\\\\\\":\\\\n                return \\\\\\\"share://\\\\\\\" + path;\\\\n                break;\\\\n            case \\\\\\\"删除\\\\\\\":\\\\n                return $(\\\\\\\"确认删除[\\\\\\\" + name + \\\\\\\"]\\\\\\\").confirm((path) => {\\\\n                    const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n                    if (File.deleteFiles(path)) {\\\\n                        if (fileExist(\\\\\\\"file://\\\\\\\" + path + \\\\\\\".json\\\\\\\")) {\\\\n                            File.deleteFiles(path + \\\\\\\".json\\\\\\\");\\\\n                        }\\\\n                        //refreshPage();\\\\n                        deleteItem(path)\\\\n                        return \\\\\\\"toast://删除成功\\\\\\\";\\\\n                    } else {\\\\n                        return \\\\\\\"toast://删除失败\\\\\\\";\\\\n                    }\\\\n                }, path);\\\\n                break;\\\\n            case \\\\\\\"阅读\\\\\\\":\\\\n                return (type===\\\\\\\".txt\\\\\\\"?\\\\\\\"hiker://page/txtParser.view\\\\\\\":\\\\\\\"hiker://page/epubParser.view#autoCache#\\\\\\\")+\\\\\\\"?rule=\\\\\\\" + MY_RULE.title;\\\\n                break;\\\\n            case \\\\\\\"打开方式\\\\\\\":\\\\n                return \\\\\\\"openFile://file://\\\\\\\" + path;\\\\n                break;\\\\n        }\\\\n    }\\\\n\\\\n    for (let novel of files) {\\\\n        let type = novel.name.substring(novel.name.lastIndexOf(\\\\\\\".\\\\\\\"));\\\\n        layout.push({\\\\n            title: novel.name,\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(operation, novel.path, novel.name, type),\\\\n            desc: \\\\\\\"大小：\\\\\\\" + File.getFileSize(novel.path) + \\\\\\\"\\\\\\\\n修改时间：\\\\\\\" + $.dateFormat(novel.lastModified, \\\\\\\"yyyy-MM-dd HH:mm:ss\\\\\\\"),\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            extra: {\\\\n                path: novel.path,\\\\n                isCache: true,\\\\n                title: novel.name,\\\\n                id: novel.path,\\\\n                longClick: [{\\\\n                    title: \\\\\\\"分享\\\\\\\",\\\\n                    js: JSON.stringify(\\\\\\\"share://\\\\\\\" + novel.path)\\\\n                }, {\\\\n                    title: \\\\\\\"阅读\\\\\\\",\\\\n                    js: JSON.stringify((type===\\\\\\\".txt\\\\\\\"?\\\\\\\"hiker://page/txtParser.view\\\\\\\":\\\\\\\"hiker://page/epubParser.view#autoCache#\\\\\\\")+\\\\\\\"?rule=\\\\\\\" + MY_RULE.title)\\\\n                }, {\\\\n                    title: \\\\\\\"打开方式\\\\\\\",\\\\n                    js: JSON.stringify(\\\\\\\"openFile://file://\\\\\\\" + novel.path)\\\\n                }, {\\\\n                    title: \\\\\\\"删除\\\\\\\",\\\\n                    js: $.toString((path) => {\\\\n                        return $.require(\\\\\\\"longPress.js\\\\\\\").deleteFileForTxt(path)\\\\n                    }, novel.path)\\\\n                }]\\\\n            }\\\\n        });\\\\n    }\\\\n    if (files.length === 0) {\\\\n        layout.push({\\\\n            title: \\\\\\\"设置\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/Setting.view#noRefresh##noRecordHistory##noHistory#\\\\\\\",\\\\n            col_type: \\\\\\\"text_2\\\\\\\",\\\\n            extra: {\\\\n                version: MY_RULE.version\\\\n            }\\\\n        });\\\\n\\\\n        layout.push({\\\\n            title: \\\\\\\"““帮助””\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/help.view#noRefresh##noRecordHistory##noHistory#?keyword=txt\\\\\\\",\\\\n            col_type: \\\\\\\"text_2\\\\\\\"\\\\n        });\\\\n        layout.push({\\\\n            title: '<h1 style=\\\\\\\"text-align: center;\\\\\\\">啥都没有耶</h1>',\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\n        });\\\\n    }\\\\n    setResult(layout);\\\\n}\\\\n\\\\nif ($.importParam === undefined) {\\\\n    $.exports = txtView;\\\\n} else if ($.importParam === null) {\\\\n    setResult(txtView([]));\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.TXT解析器\\\",\\\"path\\\":\\\"txtParser.view\\\",\\\"rule\\\":\\\"js:\\\\n(function() {\\\\n    const Config = $.require(\\\\\\\"Config.js\\\\\\\");\\\\n    let regs = $.require(\\\\\\\"hiker://page/regularChapter.f\\\\\\\");\\\\n    let path = decodeURIComponent(getParam(\\\\\\\"path\\\\\\\") || \\\\\\\"\\\\\\\") || MY_PARAMS.path;\\\\n    let charst = decodeURIComponent(getParam(\\\\\\\"charst\\\\\\\") || \\\\\\\"\\\\\\\") || MY_PARAMS.charst || \\\\\\\"UTF-8\\\\\\\";\\\\n    let isCache = decodeURIComponent(getParam(\\\\\\\"isCache\\\\\\\") || \\\\\\\"\\\\\\\") || MY_PARAMS.isCache;\\\\n    if (!path.startsWith(\\\\\\\"file://\\\\\\\")) {\\\\n        path = \\\\\\\"file://\\\\\\\" + path;\\\\n    }\\\\n    if(MY_PARAMS.title){\\\\n        setPageTitle(MY_PARAMS.title);\\\\n    }else{\\\\n        setPageTitle($.require(\\\\\\\"hiker://page/File.js\\\\\\\").getName(path));\\\\n    }\\\\n    let layout = [];\\\\n    let chapterNames = [];\\\\n    let intervals = [];\\\\n    let hasPreface = false;\\\\n    let cachePath = path.replace(Config.externalImportPath, Config.contentsCache);\\\\n    if (isCache&&fileExist(cachePath)) {\\\\n        try {\\\\n\\\\n            let c = JSON.parse(request(cachePath));\\\\n            chapterNames = c.chapterNames;\\\\n            intervals = c.intervals;\\\\n            hasPreface = c.hasPreface;\\\\n            layout.push({\\\\n                title: \\\\\\\"重新解析目录\\\\\\\",\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((path) => {\\\\n                    deleteFile(path);\\\\n                    refreshPage();\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }, path+\\\\\\\".json\\\\\\\"),\\\\n                extra: {\\\\n                    lineVisible:false\\\\n                }\\\\n            });\\\\n            layout.push({\\\\n                col_type:\\\\\\\"line_blank\\\\\\\"\\\\n            });\\\\n        } catch (e) {\\\\n            log(e.toString());\\\\n            setResult([{\\\\n                title: \\\\\\\"““””<strong>目录解析失败(重新解析)</strong>\\\\\\\".big(),\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((path) => {\\\\n                    deleteFile(path);\\\\n                    refreshPage();\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }, path+\\\\\\\".json\\\\\\\"),\\\\n                extra: {\\\\n                    lineVisible: false\\\\n                }\\\\n            }]);\\\\n            return;\\\\n        }\\\\n\\\\n    } else {\\\\n        showLoading(\\\\\\\"正在解析目录\\\\\\\");\\\\n        let txt = request(path, {\\\\n            headers: {\\\\n                //\\\\\\\"content-type\\\\\\\": \\\\\\\"text/plain; charst=\\\\\\\" + charst\\\\n            }\\\\n        });\\\\n        let pattern = regs.getTocRule(txt);\\\\n        if (!pattern) {\\\\n            hideLoading();\\\\n            setResult([{\\\\n                title: \\\\\\\"““””<strong>目录解析失败</strong>\\\\\\\".big(),\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n                    back(false);\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                }),\\\\n                extra: {\\\\n                    lineVisible: false\\\\n                }\\\\n            }]);\\\\n            return;\\\\n        }\\\\n        let matcher = pattern.matcher(txt);\\\\n        let pointer = 0;\\\\n        while (matcher.find()) {\\\\n            let start = matcher.start();\\\\n            let end = matcher.end();\\\\n            let t = matcher.group();\\\\n            if (pointer === 0 && start > 30) {\\\\n                hasPreface = true;\\\\n            }\\\\n            chapterNames.push(t);\\\\n            intervals.push([pointer, start]);\\\\n            pointer = end;\\\\n        }\\\\n        intervals.push([pointer, txt.length]);\\\\n        if (isCache) {\\\\n            writeFile(cachePath, JSON.stringify({\\\\n                chapterNames: chapterNames,\\\\n                intervals: intervals,\\\\n                hasPreface: hasPreface\\\\n            }));\\\\n        }\\\\n        hideLoading();\\\\n    }\\\\n\\\\n\\\\n    if (hasPreface) {\\\\n        let interval = intervals[0];\\\\n        layout.push({\\\\n            title: \\\\\\\"序言\\\\\\\",\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/TXTViewer.view#autoPage##readTheme#\\\\\\\",\\\\n            extra: {\\\\n                chapterName: \\\\\\\"序言\\\\\\\",\\\\n                start: interval[0],\\\\n                end: interval[1],\\\\n                path: path,\\\\n                charst: charst\\\\n            }\\\\n        });\\\\n    }\\\\n    for (let i = 0; i < chapterNames.length; i++) {\\\\n        let name = chapterNames[i];\\\\n        let interval = intervals[i + 1];\\\\n        layout.push({\\\\n            title: name,\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/TXTViewer.view#autoPage##readTheme#\\\\\\\",\\\\n            extra: {\\\\n                start: interval[0],\\\\n                end: interval[1],\\\\n                chapterName: name,\\\\n                path: path,\\\\n                charst: charst\\\\n            }\\\\n        });\\\\n    }\\\\n    setResult(layout);\\\\n})()\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.TXT查看器\\\",\\\"path\\\":\\\"TXTViewer.view\\\",\\\"rule\\\":\\\"js:\\\\nlet path = MY_PARAMS.path;\\\\nlet charst = MY_PARAMS.charst;\\\\nlet txt = request(path, {\\\\n    headers: {\\\\n       //\\\\\\\"content-type\\\\\\\": \\\\\\\"text/plain; charst=\\\\\\\" + charst\\\\n    }\\\\n});\\\\n\\\\nlet targetTexts = txt.substring(MY_PARAMS.start, MY_PARAMS.end);\\\\n\\\\nlet content = targetTexts.split(/(\\\\\\\\n|\\\\\\\\r)+/).filter(it => it.length > 1).join(\\\\\\\"<br>\\\\\\\");\\\\nlet layout = [];\\\\nlayout.push({\\\\n    col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    title: (\\\\\\\"<strong>\\\\\\\" + MY_PARAMS.chapterName + \\\\\\\"</strong>\\\\\\\").big(),\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: content,\\\\n    col_type: 'rich_text',\\\\n    extra: {\\\\n        textSize: 18,\\\\n        click: true\\\\n    }\\\\n});\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#j.章节正则\\\",\\\"path\\\":\\\"regularChapter.f\\\",\\\"rule\\\":\\\"js:\\\\nlet rules = [{\\\\n        \\\\\\\"id\\\\\\\": -1,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"目录(去空白)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?<=[　\\\\\\\\\\\\\\\\s])(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\\\\\\\\\s{0,4}[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和]))).{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"第一章 假装第一章前面有空白但我不要\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 0\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -2,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"目录\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ 　\\\\\\\\\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\\\\\\\\\s{0,4}[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|篇(?!张))).{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"第一章 标准的粤语就是这样\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 1\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -3,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"目录(匹配简介)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?<=[　\\\\\\\\\\\\\\\\s])(?:(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\\\\\\\\\s{0,4}[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|回(?![合来事去])|场(?![和合比电是])|篇(?!张))).{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"简介 老夫诸葛村夫\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 2\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -4,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"目录(古典、轻小说备用)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ 　\\\\\\\\\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|第?\\\\\\\\\\\\\\\\s{0,4}[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]+?\\\\\\\\\\\\\\\\s{0,4}(?:章|节(?!课)|卷|集(?![合和])|部(?![分赛游])|回(?![合来事去])|场(?![和合比电是])|话|篇(?!张))).{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"第一章 比上面只多了回和话\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 3\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -5,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"数字(纯数字标题)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?<=[　\\\\\\\\\\\\\\\\s])\\\\\\\\\\\\\\\\d+\\\\\\\\\\\\\\\\.?[ 　\\\\\\\\\\\\\\\\t]{0,4}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"12\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 4\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -6,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"大写数字(纯数字标题)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?<=[　\\\\\\\\\\\\\\\\s])[〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,12}[ 　\\\\\\\\\\\\\\\\t]{0,4}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"一百七十\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 4\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -7,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"数字 分隔符 标题名称\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ 　\\\\\\\\\\\\\\\\t]{0,4}\\\\\\\\\\\\\\\\d{1,5}[:：,.， 、_—\\\\\\\\\\\\\\\\-].{1,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"1、这个就是标题\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 5\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -8,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"大写数字 分隔符 标题名称\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ 　\\\\\\\\\\\\\\\\t]{0,4}(?:序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|[〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8})[ 、_—\\\\\\\\\\\\\\\\-].{1,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"一、只有前面的数字有差别\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 6\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -9,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"正文 标题/序号\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ 　\\\\\\\\\\\\\\\\t]{0,4}正文[ 　]{1,4}.{0,20}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"正文 我奶常山赵子龙\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 7\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -10,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"Chapter/Section/Part/Episode 序号 标题\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ 　\\\\\\\\\\\\\\\\t]{0,4}(?:[Cc]hapter|[Ss]ection|[Pp]art|ＰＡＲＴ|[Nn][oO]\\\\\\\\\\\\\\\\.|[Ee]pisode|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)\\\\\\\\\\\\\\\\s{0,4}\\\\\\\\\\\\\\\\d{1,4}.{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"Chapter 1 MyGrandmaIsNB\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 8\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -11,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"Chapter(去简介)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ 　\\\\\\\\\\\\\\\\t]{0,4}(?:[Cc]hapter|[Ss]ection|[Pp]art|ＰＡＲＴ|[Nn][Oo]\\\\\\\\\\\\\\\\.|[Ee]pisode)\\\\\\\\\\\\\\\\s{0,4}\\\\\\\\\\\\\\\\d{1,4}.{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"Chapter 1 MyGrandmaIsNB\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 9\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -12,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"特殊符号 序号 标题\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?<=[\\\\\\\\\\\\\\\\s　])[【〔〖「『〈［\\\\\\\\\\\\\\\\[](?:第|[Cc]hapter)[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,10}[章节].{0,20}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"【第一章 后面的符号可以没有\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 10\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -13,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"特殊符号 标题(成对)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?<=[\\\\\\\\\\\\\\\\s　]{0,4})(?:[\\\\\\\\\\\\\\\\[〈「『〖〔《（【\\\\\\\\\\\\\\\\(].{1,30}[\\\\\\\\\\\\\\\\)】）》〕〗』」〉\\\\\\\\\\\\\\\\]]?|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)[ 　]{0,4}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"『加个直角引号更专业』\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 11\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -14,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"特殊符号 标题(单个)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?<=[\\\\\\\\\\\\\\\\s　]{0,4})(?:[☆★✦✧].{1,30}|(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外)[ 　]{0,4}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"☆、晋江作者最喜欢的格式\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 12\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -15,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"章/卷 序号 标题\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^[ \\\\\\\\\\\\\\\\t　]{0,4}(?:(?:内容|文章)?简介|文案|前言|序章|楔子|正文(?!完|结)|终章|后记|尾声|番外|[卷章][\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8})[ 　]{0,4}.{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"卷五 开源盛世\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 13\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -16,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"顶格标题\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^\\\\\\\\\\\\\\\\S.{1,20}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"不超过20个字顶格写的都是标题\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 14\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -17,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"双标题(前向)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?m)(?<=[ \\\\\\\\\\\\\\\\t　]{0,4})第[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$(?=[\\\\\\\\\\\\\\\\s　]{0,8}第[\\\\\\\\\\\\\\\\d零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章)\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"第一章 真正的标题并假装换行第一章 这个不要\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 15\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -18,\\\\n        \\\\\\\"enable\\\\\\\": false,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"双标题(后向)\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"(?m)(?<=[ \\\\\\\\\\\\\\\\t　]{0,4}第[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$[\\\\\\\\\\\\\\\\s　]{0,8})第[\\\\\\\\\\\\\\\\d零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}章.{0,30}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"第一章 这个标题不要并假装换行第一章真正的标题\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 16\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -19,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"书名 括号 序号\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^.{1,20}[(（][\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}[)）][ 　\\\\\\\\t]{0,4}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"标题后面数字有括号(12)\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 17\\\\n    },\\\\n    {\\\\n        \\\\\\\"id\\\\\\\": -20,\\\\n        \\\\\\\"enable\\\\\\\": true,\\\\n        \\\\\\\"name\\\\\\\": \\\\\\\"书名 序号\\\\\\\",\\\\n        \\\\\\\"rule\\\\\\\": \\\\\\\"^.{1,20}[\\\\\\\\\\\\\\\\d〇零一二两三四五六七八九十百千万壹贰叁肆伍陆柒捌玖拾佰仟]{1,8}[ 　\\\\\\\\t]{0,4}$\\\\\\\",\\\\n        \\\\\\\"example\\\\\\\": \\\\\\\"标题后面数字没有括号124\\\\\\\",\\\\n        \\\\\\\"serialNumber\\\\\\\": 18\\\\n    }\\\\n];\\\\nlet Matcher = java.util.regex.Matcher;\\\\nlet Pattern = java.util.regex.Pattern;\\\\n\\\\nfunction getTocRule(content) {\\\\n    let maxCs = 1;\\\\n    let tocPattern = null;\\\\n    for (let tocRule of rules) {\\\\n        if (!tocRule.enable) continue;\\\\n        let pattern = Pattern.compile(tocRule.rule, Pattern.MULTILINE);\\\\n        let matcher = pattern.matcher(content);\\\\n        let cs = 0;\\\\n        while (matcher.find()) {\\\\n            cs++;\\\\n        }\\\\n        if (cs >= maxCs) {\\\\n            maxCs = cs;\\\\n            tocPattern = pattern;\\\\n        }\\\\n    }\\\\n    return tocPattern;\\\\n}\\\\n$.exports.getTocRule = getTocRule;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#V.帮助\\\",\\\"path\\\":\\\"help.view\\\",\\\"rule\\\":\\\"js:\\\\nlet helpText = {\\\\n    \\\\\\\"txt\\\\\\\": `\\\\n        <h1 id=\\\\\\\"txt是什么\\\\\\\">TXT是什么?</h1>\\\\n        <p><a href=\\\\\\\"https://baike.baidu.com/item/txt/1217330\\\\\\\">我已经帮你百度了</a>；简单来说就是一种储存小说的文件(扩展名:txt)。</p>\\\\n        <h1 id=\\\\\\\"如何用该小程序阅读txt小说\\\\\\\">如何用该小程序阅读txt小说?</h1>\\\\n        <p>在主页面 ◉TXT 界面下，点击导入TXT，选择目标小说文件(txt文件，<em>该操作不会删除txt文件，而是copy一份到小程序的路径下</em>)，导入后再在 ◉TXT 界面下选择想要阅读的小说即可。</p>\\\\n\\\\n    `,\\\\n    \\\\\\\"novelComic\\\\\\\": `\\\\n        <h1 id=\\\\\\\"这个小程序有什么用？\\\\\\\">这个小程序有什么用？</h1>\\\\n        <ul>\\\\n        <li><u>代码上为其他小程序(漫画类/小说类)提供下载接口。</u></li>\\\\n        <li><u>本体充当阅读器，可以浏览用该小程序提供的下载接口(上面)，下载的漫画/小说。</u></li>\\\\n        <li><u>提供TXT格式小说文件解析功能。</u>\\\\n        <h1 id=\\\\\\\"为什么列表里什么都没用\\\\\\\">为什么列表里什么都没用?</h1>\\\\n        <u>初次使用，没有很正常吧。🤔</u>\\\\n        <h1 id=\\\\\\\"该如何添加漫画或小说\\\\\\\">该如何添加漫画(或小说)?</h1>\\\\n        <u> 在一个有下载功能的小程序(漫画类/小说类)中下载一本漫画/小说，返回该规则即可浏览。</u></li>\\\\n        </ul>\\\\n    `\\\\n};\\\\nsetPageTitle(\\\\\\\"帮助\\\\\\\");\\\\nlet keyword = getParam(\\\\\\\"keyword\\\\\\\");\\\\nlet text;\\\\nif (keyword === undefined || !(text = helpText[keyword])) {\\\\n    setResult([{\\\\n        title: '<h1 style=\\\\\\\"text-align: center;\\\\\\\">资料不见咯</h1>',\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    }]);\\\\n} else {\\\\n    setResult([{\\\\n        title: text,\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    }]);\\\\n}\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"#v.外导搜索\\\",\\\"path\\\":\\\"txtSearch.view\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\n\\\\nlet searchTerms = decodeURIComponent(getParam(\\\\\\\"searchTerms\\\\\\\"));\\\\nsetPageTitle(\\\\\\\"「\\\\\\\" + searchTerms + \\\\\\\"」的搜索结果\\\\\\\");\\\\nlet data = File.getFilePath(Config.externalImportPath, undefined);\\\\ndata = data.filter(v => /(\\\\\\\\.txt|\\\\\\\\.epub)$/.test(v.name));\\\\n\\\\nlet termsArr = searchTerms.split(\\\\\\\"\\\\\\\").map(t => t.replace(/\\\\\\\\*|\\\\\\\\.|\\\\\\\\?|\\\\\\\\+|\\\\\\\\$|\\\\\\\\^|\\\\\\\\[|\\\\\\\\]|\\\\\\\\(|\\\\\\\\)|\\\\\\\\{|\\\\\\\\}|\\\\\\\\||\\\\\\\\/|\\\\\\\\\\\\\\\\/g, k => \\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\" + k));\\\\nlet reg = new RegExp(termsArr.join(\\\\\\\".*\\\\\\\"), \\\\\\\"i\\\\\\\");\\\\nlet searchResult = [];\\\\nfor (let txt of data) {\\\\n    if (reg.test(txt.name)) {\\\\n        let type = txt.name.substring(txt.name.lastIndexOf(\\\\\\\".\\\\\\\"));\\\\n        searchResult.push({\\\\n            title: txt.name,\\\\n            url: (type===\\\\\\\".txt\\\\\\\"?\\\\\\\"hiker://page/txtParser.view\\\\\\\":\\\\\\\"hiker://page/epubParser.view#autoCache#\\\\\\\")+\\\\\\\"?rule=\\\\\\\" + MY_RULE.title,\\\\n            desc: txt.path,\\\\n            extra: {\\\\n                path: txt.path,\\\\n                isCache: true,\\\\n                title: txt.name\\\\n            }\\\\n        });\\\\n    }\\\\n}\\\\nif (searchResult.length === 0) {\\\\n    searchResult.push({\\\\n        col_type: \\\\\\\"big_big_blank_block\\\\\\\",\\\\n    }, {\\\\n        col_type: \\\\\\\"big_big_blank_block\\\\\\\",\\\\n    }, {\\\\n        col_type: \\\\\\\"big_big_blank_block\\\\\\\",\\\\n    }, {\\\\n        col_type: \\\\\\\"big_big_blank_block\\\\\\\",\\\\n    }, {\\\\n        title: '<h2 style=\\\\\\\"text-align: center;\\\\\\\">🔎没有找到相关书籍</h2>',\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    });\\\\n}\\\\nsetResult(searchResult);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#f.长按/点击\\\",\\\"path\\\":\\\"longPress.js\\\",\\\"rule\\\":\\\"js:\\\\n$.exports = {\\\\n    deleteFileForBook(path) {\\\\n        //return $(\\\\\\\"所有的 漫画/小说 章节将被删除\\\\\\\\m确认删除？\\\\\\\").confirm((path) => {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        if (File.deleteFiles(path)) {\\\\n            deleteItem(path)\\\\n            return \\\\\\\"toast://删除成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://删除失败\\\\\\\";\\\\n        }\\\\n        //}, path);\\\\n    },\\\\n    deleteFileForTxt(path) {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        if (File.deleteFiles(path)) {\\\\n            if (fileExist(\\\\\\\"file://\\\\\\\" + path + \\\\\\\".json\\\\\\\")) {\\\\n                File.deleteFiles(path + \\\\\\\".json\\\\\\\");\\\\n            }\\\\n            deleteItem(path);\\\\n            return \\\\\\\"toast://删除成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://删除失败\\\\\\\";\\\\n        }\\\\n    },\\\\n    singleEnter(pageUrl, path) {\\\\n        const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\n        let dirs = File.getFilePath(path, \\\\\\\"dir\\\\\\\");\\\\n        if (dirs.length === 1) {\\\\n            const Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\n            let fi = dirs[0].path;\\\\n            if (Config.def_isComicCompatible === \\\\\\\"0\\\\\\\") {\\\\n                let filelist = File.getFilePath(fi);\\\\n                let shorten = fi.replace(getPath(\\\\\\\"hiker://files/\\\\\\\").slice(7), \\\\\\\"hiker://files/\\\\\\\");\\\\n                let piclist = filelist.map((item, i) => shorten + \\\\\\\"/\\\\\\\" + (i + 1) + \\\\\\\".jpg\\\\\\\");\\\\n                return \\\\\\\"pics://\\\\\\\" + piclist.join(\\\\\\\"&&\\\\\\\");\\\\n\\\\n            } else {\\\\n                return \\\\\\\"hiker://page/comicCompatible.view#autoPage##readTheme#?path=\\\\\\\" + encodeURIComponent(fi);\\\\n            }\\\\n        } else {\\\\n            return pageUrl + \\\\\\\"?rule=\\\\\\\" + MY_RULE.title\\\\n        }\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#fg.下载主程序\\\",\\\"path\\\":\\\"mainDownload\\\",\\\"rule\\\":\\\"const File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"hiker://page/Tool.js\\\\\\\");\\\\n\\\\n\\\\n$.exports.novel = function novel(item, info, order, MY_ID, interrupt) {\\\\n    let id = info.bookId ? \\\\\\\"$\\\\\\\" + info.bookId : \\\\\\\"\\\\\\\";\\\\n    let mainPath = Config.novelPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + Tool.textShield(info.bookName) + id + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + order + \\\\\\\"$A$\\\\\\\" + Tool.textShield(item.title) + \\\\\\\".txt\\\\\\\";\\\\n    let content = \\\\\\\"\\\\\\\";\\\\n    if (interrupt && getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n        return -1;\\\\n    }\\\\n    try {\\\\n        let setResult = data => {\\\\n            content = data[0].title || \\\\\\\"\\\\\\\";\\\\n            if (data.length > 1 && data[1].title && data[1].title.length > content.length) {\\\\n                content = data[1].title;\\\\n            }\\\\n        }\\\\n        let getResCode = () => {\\\\n            return fetch(item.url);\\\\n        }\\\\n        let getContent = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"index\\\\\\\", \\\\\\\"title\\\\\\\", \\\\\\\"setResult\\\\\\\", \\\\\\\"getResCode\\\\\\\", \\\\\\\"return \\\\\\\" + info.parseCode);\\\\n        content = getContent(item.url, item.url, order, item.title, setResult, getResCode) || content || \\\\\\\"\\\\\\\";\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<小说正文解析错误> \\\\\\\" + e.message;\\\\n        throw e;\\\\n    }\\\\n    if (!content) {\\\\n        toast(\\\\\\\"小说为空\\\\\\\");\\\\n        throw new Error(\\\\\\\"<小说正文解析错误：正文返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + id + \\\\\\\".jpg\\\\\\\", bookTopPic[1], info.decode);\\\\n\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误> \\\\\\\" + e.message);\\\\n        }\\\\n    }\\\\n    File.fileWrite(chapterPath, content.replace(/<script>.*?<\\\\\\\\/script>/gmi, \\\\\\\"\\\\\\\").trimRight());\\\\n    //File.renameFile(chapterPath, order + \\\\\\\"$A$\\\\\\\" + item.title + \\\\\\\".txt\\\\\\\");\\\\n}\\\\n\\\\n$.exports.comic = function comic(item, info, order, MY_ID, interrupt) {\\\\n    let id = info.bookId ? \\\\\\\"$\\\\\\\" + info.bookId : \\\\\\\"\\\\\\\";\\\\n    let mainPath = Config.comicPath + \\\\\\\"/\\\\\\\" + info.ruleName + \\\\\\\"/\\\\\\\" + Tool.textShield(info.bookName) + id + \\\\\\\"/\\\\\\\";\\\\n    let chapterPath = mainPath + order + \\\\\\\"$B$\\\\\\\" + Tool.textShield(item.title) + \\\\\\\"/\\\\\\\";\\\\n    let picList = [];\\\\n    try {\\\\n        let getPicList = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"index\\\\\\\", \\\\\\\"title\\\\\\\", \\\\\\\"return\\\\\\\" + info.parseCode);\\\\n        picList = getPicList(item.url, item.url, order, item.title);\\\\n        if (typeof picList === \\\\\\\"string\\\\\\\") {\\\\n            picList = picList.replace(\\\\\\\"pics://\\\\\\\", \\\\\\\"\\\\\\\").split(\\\\\\\"&&\\\\\\\");\\\\n        }\\\\n    } catch (e) {\\\\n        e.message = \\\\\\\"<漫画图片解析错误> \\\\\\\" + e.message;\\\\n        throw e;\\\\n    }\\\\n    picList = picList.filter(p => p);\\\\n    const L = picList.length;\\\\n    if (L === 0) {\\\\n        toast(\\\\\\\"图片链接为空\\\\\\\");\\\\n        throw new Error(\\\\\\\"<漫画图片解析错误：图片链接返回为空>\\\\\\\");\\\\n    }\\\\n    if (info.bookTopPic) {\\\\n        try {\\\\n            let bookTopPic = Tool.hikerPic(info.bookTopPic);\\\\n            Tool.picDownload(bookTopPic[0], mainPath + info.bookName + id + \\\\\\\".jpg\\\\\\\", bookTopPic[1], info.decode);\\\\n        } catch (e) {\\\\n            log(\\\\\\\"<封面下载错误> \\\\\\\" + e.message);\\\\n        }\\\\n    }\\\\n\\\\n    let errorNum = 0;\\\\n    for (var i = 0; i < L; i++) {\\\\n        try {\\\\n            let pic = Tool.hikerPic(picList[i]);\\\\n            Tool.picDownload(pic[0], chapterPath + (i + 1) + \\\\\\\".jpg\\\\\\\", pic[1], info.decode);\\\\n            if (interrupt && getMyVar(MY_ID + \\\\\\\":status\\\\\\\", \\\\\\\"\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n                return -1;\\\\n            }\\\\n            errorNum = 0;\\\\n        } catch (e) {\\\\n            if (errorNum < 10) {\\\\n                i--;\\\\n                errorNum++;\\\\n                continue;\\\\n            } else {\\\\n                throw e;\\\\n            }\\\\n        }\\\\n    }\\\\n\\\\n    File.renameFile(chapterPath, order + \\\\\\\"$A$\\\\\\\" + Tool.textShield(item.title));\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.漫画兼容\\\",\\\"path\\\":\\\"comicCompatible.view\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js\\\\\\\");\\\\nsetPageTitle(MY_PARAMS.title);\\\\nlet path=decodeURIComponent(getParam(\\\\\\\"path\\\\\\\",MY_PARAMS.path));\\\\nlet filelist = File.getFilePath(path);\\\\nlet piclist = filelist.map((item, i) => ({\\\\n    col_type: \\\\\\\"pic_1_full\\\\\\\",\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    pic_url: path + \\\\\\\"/\\\\\\\" + (i + 1) + \\\\\\\".jpg\\\\\\\"\\\\n}));\\\\n\\\\nsetResult(piclist);\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.书架\\\",\\\"path\\\":\\\"Bookrack.view\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"File.js\\\\\\\");\\\\nconst rank = $.require(\\\\\\\"fileRank.js\\\\\\\");\\\\nconst Tool = $.require(\\\\\\\"Tool.js\\\\\\\");\\\\nconst Config = $.require(\\\\\\\"Config.js\\\\\\\");\\\\n\\\\n(function() {\\\\n    let type = MY_PARAMS.type || getParam(\\\\\\\"type\\\\\\\", \\\\\\\"\\\\\\\") || \\\\\\\"comic\\\\\\\";\\\\n    let ruleName = Tool.textShield(MY_PARAMS.ruleName || decodeURIComponent(getParam(\\\\\\\"ruleName\\\\\\\")));\\\\n    if (!ruleName) {\\\\n        toast(\\\\\\\"请传入规则名\\\\\\\");\\\\n        back(false);\\\\n    }\\\\n    if (![\\\\\\\"comic\\\\\\\", \\\\\\\"novel\\\\\\\"].includes(type)) {\\\\n        toast(\\\\\\\"请传入正确的type:comic novel\\\\\\\");\\\\n        back(false);\\\\n    }\\\\n    setPageTitle(ruleName + \\\\\\\"|本地书架\\\\\\\");\\\\n    let layout = [];\\\\n    let path = Config[type + \\\\\\\"Path\\\\\\\"] + ruleName;\\\\n    let col_type = getItem(\\\\\\\"bookrack:col_type\\\\\\\", \\\\\\\"movie_3_marquee\\\\\\\");\\\\n    let rankMethod = getItem(\\\\\\\"bookrack:rankMethod\\\\\\\", \\\\\\\"系统\\\\\\\");\\\\n    let rankIsReverse = getItem(\\\\\\\"bookrack:rankIsReverse\\\\\\\", \\\\\\\"\\\\\\\");\\\\n\\\\n    let colTypes = [\\\\\\\"movie_1\\\\\\\", \\\\\\\"movie_2\\\\\\\", \\\\\\\"movie_3_marquee\\\\\\\", \\\\\\\"movie_1_vertical_pic\\\\\\\", \\\\\\\"pic_2\\\\\\\", \\\\\\\"pic_3\\\\\\\", \\\\\\\"pic_3_square\\\\\\\", \\\\\\\"pic_2_card\\\\\\\"];\\\\n    \\\\n    let rankMethods = [\\\\\\\"系统\\\\\\\", \\\\\\\"大小\\\\\\\", \\\\\\\"名称\\\\\\\", \\\\\\\"时间\\\\\\\"];\\\\n    layout.push({\\\\n        url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n        desc: \\\\\\\"搜你想要的#\\\\\\\" + type + \\\\\\\"#......\\\\\\\",\\\\n        title: \\\\\\\"🔍\\\\\\\",\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            rules: $.toString((ruleName, type) => {\\\\n                let arr1 = [{\\\\n                        \\\\\\\"title\\\\\\\": ruleName,\\\\n                        \\\\\\\"search_url\\\\\\\": \\\\\\\"hiker://empty?isAll=1&searchTerms=**&type=\\\\\\\" + type,\\\\n                        \\\\\\\"searchFind\\\\\\\": \\\\\\\"js:$.require('hiker://page/Search.view?rule='+MY_RULE._title);\\\\\\\"\\\\n                    }];\\\\n                \\\\n                return JSON.stringify(arr1);\\\\n            }, ruleName, type),\\\\n            /*defaultValue: getMyVar('searchKey', ''),\\\\n            onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"*/\\\\n        }\\\\n    });\\\\n\\\\n    layout.push({\\\\n        title: \\\\\\\"🧩\\\\\\\",\\\\n        col_type: \\\\\\\"flex_button\\\\\\\",\\\\n        url: $(colTypes.map(v=>v===col_type?\\\\\\\"““\\\\\\\"+v+\\\\\\\"””\\\\\\\":v)).select((name) => {\\\\n            if(/““.*?””/.test(input)) return;\\\\n            setItem(\\\\\\\"bookrack:col_type\\\\\\\", input);\\\\n            refreshPage();\\\\n        })\\\\n    });\\\\n    for (let name of rankMethods) {\\\\n        let a = rankMethod === name;\\\\n        let titlea = a ? \\\\\\\"‘‘\\\\\\\" + name + \\\\\\\"’’\\\\\\\" : name;\\\\n        let titleb = \\\\\\\"\\\\\\\";\\\\n        if (a) {\\\\n            titleb = !rankIsReverse ? \\\\\\\"↓\\\\\\\" : \\\\\\\"↑\\\\\\\";\\\\n        } else {\\\\n            titleb = \\\\\\\"↕\\\\\\\";\\\\n        }\\\\n        layout.push({\\\\n            title: titlea + titleb,\\\\n            col_type: \\\\\\\"flex_button\\\\\\\",\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((name) => {\\\\n                let rankMethod = getItem(\\\\\\\"bookrack:rankMethod\\\\\\\", \\\\\\\"系统\\\\\\\");\\\\n                let rankIsReverse = getItem(\\\\\\\"bookrack:rankIsReverse\\\\\\\", \\\\\\\"\\\\\\\");\\\\n\\\\n                if (rankMethod === name) {\\\\n                    if (rankIsReverse) {\\\\n                        rankIsReverse = \\\\\\\"\\\\\\\";\\\\n                    } else {\\\\n                        rankIsReverse = \\\\\\\"1\\\\\\\";\\\\n                    }\\\\n\\\\n                    setItem(\\\\\\\"bookrack:rankIsReverse\\\\\\\", rankIsReverse);\\\\n                } else {\\\\n                    setItem(\\\\\\\"bookrack:rankIsReverse\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                    setItem(\\\\\\\"bookrack:rankMethod\\\\\\\", name);\\\\n\\\\n                }\\\\n                refreshPage(false);\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n            }, name)\\\\n        });\\\\n    }\\\\n    let rankMethodMap = {\\\\n        \\\\\\\"系统\\\\\\\": \\\\\\\"\\\\\\\",\\\\n        \\\\\\\"大小\\\\\\\": \\\\\\\"size\\\\\\\",\\\\n        \\\\\\\"名称\\\\\\\": \\\\\\\"name\\\\\\\",\\\\n        \\\\\\\"时间\\\\\\\": \\\\\\\"time\\\\\\\"\\\\n    };\\\\n    let bookList = [];\\\\n    let list = rank(File.getFiles(path, \\\\\\\"dir\\\\\\\"), rankMethodMap[rankMethod]);\\\\n    if (list.length === 0) {\\\\n        bookList.push({\\\\n            title: \\\\\\\"““””\\\\\\\" + \\\\\\\"啥都没有耶\\\\\\\".big(),\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        });\\\\n\\\\n    }\\\\n    let pageUrl = type === \\\\\\\"novel\\\\\\\" ? \\\\\\\"hiker://page/NovelBrowser.view\\\\\\\" : \\\\\\\"hiker://page/ComicBrowser.view\\\\\\\";\\\\n    for (let item of list) {\\\\n        let pic = fileExist(\\\\\\\"file://\\\\\\\" + item.getPath() + \\\\\\\"/\\\\\\\" + item.getName() + \\\\\\\".jpg\\\\\\\") ? item.getPath() + \\\\\\\"/\\\\\\\" + item.getName() + \\\\\\\".jpg\\\\\\\" : Config.def_Pic;\\\\n        let names=String(item.getName()).split(\\\\\\\"$\\\\\\\");\\\\n        bookList.push({\\\\n            title: names[0],\\\\n            desc: names[1],\\\\n            pic_url: pic,\\\\n            url: type === \\\\\\\"novel\\\\\\\" ?pageUrl + \\\\\\\"?rule=\\\\\\\" + MY_RULE.title:$(\\\\\\\"#noLoading#\\\\\\\").lazyRule((pageUrl, path)=>{\\\\n                return $.require(\\\\\\\"longPress.js\\\\\\\").singleEnter(pageUrl, path);\\\\n            }, pageUrl, item.getPath()),\\\\n            col_type:col_type,\\\\n            extra: {\\\\n                longClick: [{\\\\n                    title: \\\\\\\"删除\\\\\\\",\\\\n                    js: $.toString((path) => {\\\\n                        return $.require(\\\\\\\"longPress.js\\\\\\\").deleteFileForBook(path);\\\\n                    }, item.getPath())\\\\n                }],\\\\n                id: item.getPath(),\\\\n                path: item.getPath(),\\\\n                name: item.getName()\\\\n            }\\\\n        });\\\\n    }\\\\n    if (rankIsReverse) {\\\\n        bookList.reverse();\\\\n    }\\\\n\\\\n    setResult(layout.concat(bookList));\\\\n})();\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#f.文件排序\\\",\\\"path\\\":\\\"fileRank.js\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"File.js\\\\\\\");\\\\nlet chnNumChar = {\\\\n    零: 0,\\\\n    一: 1,\\\\n    二: 2,\\\\n    三: 3,\\\\n    四: 4,\\\\n    五: 5,\\\\n    六: 6,\\\\n    七: 7,\\\\n    八: 8,\\\\n    九: 9\\\\n};\\\\n\\\\nlet chnNameValue = {\\\\n    十: {\\\\n        value: 10,\\\\n        secUnit: false\\\\n    },\\\\n    百: {\\\\n        value: 100,\\\\n        secUnit: false\\\\n    },\\\\n    千: {\\\\n        value: 1000,\\\\n        secUnit: false\\\\n    },\\\\n    万: {\\\\n        value: 10000,\\\\n        secUnit: true\\\\n    },\\\\n    亿: {\\\\n        value: 100000000,\\\\n        secUnit: true\\\\n    }\\\\n}\\\\n\\\\nfunction ChineseToNumber(chnStr) {\\\\n    let rtn = 0;\\\\n    let section = 0;\\\\n    let number = 0;\\\\n    let secUnit = false;\\\\n    let str = chnStr.split('');\\\\n\\\\n    for (let i = 0; i < str.length; i++) {\\\\n        let num = chnNumChar[str[i]];\\\\n        if (typeof num !== 'undefined') {\\\\n            number = num;\\\\n            if (i === str.length - 1) {\\\\n                section += number;\\\\n            }\\\\n        } else {\\\\n            let unit = chnNameValue[str[i]].value;\\\\n            secUnit = chnNameValue[str[i]].secUnit;\\\\n            if (secUnit) {\\\\n                section = (section + number) * unit;\\\\n                rtn += section;\\\\n                section = 0;\\\\n            } else {\\\\n                section += (number * unit);\\\\n            }\\\\n            number = 0;\\\\n        }\\\\n    }\\\\n    return rtn + section;\\\\n}\\\\n\\\\nfunction nameCompare(a, b) {\\\\n    if (a == null || b == null)\\\\n        return a == null ? b == null ? 0 : -1 : 1;\\\\n\\\\n    a = a.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\\\n        return ChineseToNumber(p1);\\\\n    })\\\\n    b = b.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\\\n        return ChineseToNumber(p1);\\\\n    })\\\\n\\\\n    let NUMBERS = java.util.regex.Pattern.compile(\\\\\\\"(?<=\\\\\\\\\\\\\\\\D)(?=\\\\\\\\\\\\\\\\d)|(?<=\\\\\\\\\\\\\\\\d)(?=\\\\\\\\\\\\\\\\D)\\\\\\\");\\\\n    let split1 = NUMBERS.split(new java.lang.String(a));\\\\n    let split2 = NUMBERS.split(new java.lang.String(b));\\\\n\\\\n    for (let i = 0; i < Math.min(split1.length, split2.length); i++) {\\\\n        let c1 = split1[i].charCodeAt(0);\\\\n        let c2 = split2[i].charCodeAt(0);\\\\n        let cmp = 0;\\\\n        let zeroCharCode = '0'.charCodeAt(0);\\\\n        let nineCharCode = '9'.charCodeAt(0);\\\\n\\\\n        if (c1 >= zeroCharCode && c1 <= nineCharCode && c2 >= zeroCharCode && c2 <= nineCharCode) {\\\\n            cmp = new java.math.BigInteger(split1[i]).compareTo(new java.math.BigInteger(split2[i]));\\\\n        }\\\\n\\\\n        if (cmp === 0) {\\\\n            let regex = /[a-zA-Z0-9]/\\\\n            let s1 = String(split1[i])\\\\n            let s2 = String(split2[i])\\\\n            if (regex.test(s1) || regex.test(s2)) {\\\\n                cmp = new java.lang.String(split1[i]).compareTo(new java.lang.String(split2[i]));\\\\n                // cmp = s1.localeCompare(s2, 'en')\\\\n            } else {\\\\n                cmp = s1.localeCompare(s2, 'zh')\\\\n            }\\\\n        }\\\\n\\\\n        if (cmp !== 0) {\\\\n            return cmp;\\\\n        }\\\\n    }\\\\n    let lengthCmp = split1.length - split2.length;\\\\n    // if (lengthCmp !== 0) lengthCmp = lengthCmp > 0 ? -1 : 1;\\\\n    return lengthCmp;\\\\n}\\\\n\\\\nfunction rank(list, m) {\\\\n    switch (m) {\\\\n        case \\\\\\\"type\\\\\\\":\\\\n            return list;\\\\n        case \\\\\\\"name\\\\\\\":\\\\n            return list.sort((a, b) => nameCompare(String(a.getName()), String(b.getName())));\\\\n        case \\\\\\\"size\\\\\\\":\\\\n            return list.sort((a, b) => File.getTotalSizeOfFilesInDir(a) - File.getTotalSizeOfFilesInDir(b));\\\\n        case \\\\\\\"time\\\\\\\":\\\\n            return list.sort((a, b) => a.lastModified() - b.lastModified());\\\\n        default:\\\\n            return list;\\\\n    }\\\\n\\\\n}\\\\n$.exports=rank;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.epub解析器\\\",\\\"path\\\":\\\"epubParser.view\\\",\\\"rule\\\":\\\"js:\\\\nvar layout = [];\\\\nsetPageTitle(\\\\\\\"书籍信息\\\\\\\");\\\\nlet path = decodeURIComponent(getParam(\\\\\\\"path\\\\\\\") || \\\\\\\"\\\\\\\") || MY_PARAMS.path;\\\\nlet meta = getEpubMetadata(path);\\\\n//log(meta)\\\\n\\\\nlayout.push({\\\\n    title: meta.firstTitle,\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: \\\\\\\"👤作者：\\\\\\\" + meta.authors[0].lastname,\\\\n    col_type: \\\\\\\"rich_text\\\\\\\",\\\\n});\\\\nlet description = (meta.descriptions[0] || \\\\\\\"\\\\\\\").replace(/<p.*?>|<\\\\\\\\/p>/g, \\\\\\\"\\\\\\\");\\\\nlet tdescription = description;\\\\nif (description) {\\\\n    \\\\n    if (description.length > 50) {\\\\n        description = description.substring(0, 50) +\\\\\\\"......\\\\\\\" +\\\\\\\"更多>\\\\\\\".link($().b64(\\\\\\\"'\\\\\\\").rule(() => {\\\\n            setPageTitle(\\\\\\\"简介\\\\\\\");\\\\n            setResult([{\\\\n                title: \\\\\\\"简介：<br>　　\\\\\\\" + MY_PARAMS.text,\\\\n                col_type: \\\\\\\"rich_text\\\\\\\",\\\\n\\\\n            }]);\\\\n        }));\\\\n    }\\\\n    layout.push({\\\\n        title: \\\\\\\"📝简介：<br>　　\\\\\\\"+description,\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n        extra: {\\\\n            text: tdescription\\\\n        }\\\\n    });\\\\n}\\\\n//setPageTitle(meta.firstTitle);\\\\nlayout.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\",\\\\n    url: \\\\\\\"hiker://empty\\\\\\\"\\\\n});\\\\nlet chapters = getEpubChapters(path);\\\\nfor (let it of chapters) {\\\\n    layout.push({\\\\n        title: it.title,\\\\n        url: \\\\\\\"hiker://page/epubViewer.view#readTheme##autoPage#\\\\\\\",\\\\n        col_type: \\\\\\\"text_1\\\\\\\",\\\\n        extra: {\\\\n            href: it.url,\\\\n            path: path,\\\\n            title: it.title\\\\n        }\\\\n    });\\\\n}\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v.epub查看器\\\",\\\"path\\\":\\\"epubViewer.view\\\",\\\"rule\\\":\\\"js:\\\\nlet path = MY_PARAMS.path;\\\\nlet url = MY_PARAMS.href;\\\\nlet c = getEpubContent(path, url);\\\\n//let a= c.replace(/\\\\\\\\s?<div.*?>|<\\\\\\\\/div>\\\\\\\\s?/g, \\\\\\\"\\\\\\\").replace(/\\\\\\\\s?<p.*?>(.*)<\\\\\\\\/p>\\\\\\\\s?/g, \\\\\\\"\\\\\\\\u3000\\\\\\\\u3000$1<br>\\\\\\\");\\\\n//let b=c.replace(/\\\\\\\\s?<div.*?>|<\\\\\\\\/div>\\\\\\\\s?/g, \\\\\\\"\\\\\\\").replace(/\\\\\\\\s?<p.*?>(.*?)<\\\\\\\\/p>\\\\\\\\s?/g, \\\\\\\"\\\\\\\\u3000\\\\\\\\u3000$1<br>\\\\\\\");\\\\n//log(a==b)\\\\n//log(getEpubContent0(path, url))\\\\n\\\\nlet layout = [];\\\\nlayout.push({\\\\n    col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    title: (\\\\\\\"<strong>\\\\\\\" + MY_PARAMS.title + \\\\\\\"</strong>\\\\\\\").big(),\\\\n});\\\\n\\\\nlayout.push({\\\\n    title: c,\\\\n    col_type: 'rich_text',\\\\n    extra: {\\\\n        textSize: 18,\\\\n        click: true\\\\n    }\\\\n});\\\\nsetResult(layout);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#v文件管理\\\",\\\"path\\\":\\\"FileManagement.view\\\",\\\"rule\\\":\\\"js:\\\\nconst Config = $.require(\\\\\\\"hiker://page/Config.js\\\\\\\");\\\\nlet url = \\\\\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\\\\\";\\\\nlet f = $.require(url);\\\\nlet type = getParam(\\\\\\\"type\\\\\\\", \\\\\\\"homePath\\\\\\\");\\\\naddListener(\\\\\\\"onClose\\\\\\\", () => {\\\\n    refreshPage();\\\\n});\\\\nlet hikerPath = \\\\\\\"file://\\\\\\\" + Config.homePath;\\\\nif(!fileExist(hikerPath)){\\\\n    writeFile(hikerPath+\\\\\\\"/创建目录.txt\\\\\\\",\\\\\\\"\\\\\\\");\\\\n    deleteFile(hikerPath+\\\\\\\"/创建目录.txt\\\\\\\");\\\\n}\\\\nf.fileSelection({\\\\n    callback: $.toString(() => {\\\\n        //根据文件扩展名，用不同小程序打开\\\\n        if (\\\\\\\".jpg\\\\\\\" === TYPE) {\\\\n            return PATH;\\\\n        } else if (\\\\\\\".txt\\\\\\\" === TYPE) {\\\\n            return \\\\\\\"hiker://page/txtParser.view?isCache=true&rule=\\\\\\\" + MY_RULE.title + \\\\\\\"&path=\\\\\\\" + PATH;\\\\n        } else if (\\\\\\\".epub\\\\\\\" === TYPE) {\\\\n            return \\\\\\\"hiker://page/epubParser.view#autoCache#?rule=\\\\\\\" + MY_RULE.title + \\\\\\\"&path=\\\\\\\" + PATH;\\\\n        } else {\\\\n            return $(\\\\\\\"无法打开，是否使用其他应用打开？\\\\\\\").confirm(path => \\\\\\\"openFile://file://\\\\\\\" + path, PATH);\\\\n        }\\\\n    }),\\\\n    initialPath: Config[type],\\\\n    rootDirPath: Config.homePath,\\\\n    //onClickType: \\\\\\\"confirm\\\\\\\",\\\\n    //memory: \\\\\\\"FileManagement:memory\\\\\\\",\\\\n    fileType: \\\\\\\"\\\\\\\\.txt|\\\\\\\\.epub|.jpg\\\\\\\",\\\\n    //cHomeTips: \\\\\\\"是否使用海阔小程序打开[${name}]?\\\\\\\",\\\\n    //cSearchTips: \\\\\\\"是否使用海阔小程序打开[${path}]?\\\\\\\"\\\\n});\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"#j.Config\\\",\\\"path\\\":\\\"Config.js\\\",\\\"rule\\\":\\\"js:\\\\nconst File = $.require(\\\\\\\"hiker://page/File.js?rule=本地资源管理\\\\\\\");\\\\n\\\\nlet localConfig = {};\\\\n\\\\ntry {\\\\n    localConfig = JSON.parse(File.readFile(getPath(\\\\\\\"hiker://files/rules/files/本地资源管理/config.json\\\\\\\").slice(7)));\\\\n} catch (e) {\\\\n    deleteFile(\\\\\\\"config.json\\\\\\\");\\\\n}\\\\nconst Config = Object.assign({\\\\n    homePath: getPath(\\\\\\\"hiker://files/localManager\\\\\\\").slice(7),\\\\n    logNum: 10,\\\\n    threadNum: 0,\\\\n    def_isPaginate: \\\\\\\"1\\\\\\\", //1默认开启分页，0默认关闭\\\\n    viewPageSize: 200,\\\\n    def_Pic: \\\\\\\"hiker://images/home_pic4\\\\\\\",\\\\n    def_Lord_Type: \\\\\\\"comic\\\\\\\",\\\\n    def_View_Style: \\\\\\\"text_1\\\\\\\",\\\\n    def_DoVi_Style: \\\\\\\"text_2\\\\\\\",\\\\n    def_DoVi_Type: \\\\\\\"1\\\\\\\", //0全部, 1未完成，2已完成\\\\n    def_isComicCompatible: \\\\\\\"0\\\\\\\",\\\\n    def_Comic_Style: \\\\\\\"text_1\\\\\\\"\\\\n}, localConfig);\\\\nconst PATHS = {\\\\n    novelPath: \\\\\\\"/小说/\\\\\\\",\\\\n    comicPath: \\\\\\\"/漫画/\\\\\\\",\\\\n    novelFullPath: \\\\\\\"/小说合并/\\\\\\\",\\\\n    externalImportPath: \\\\\\\"/外导小说/\\\\\\\",\\\\n    contentsCache: \\\\\\\"/目录缓存/\\\\\\\"\\\\n}\\\\n\\\\n\\\\nObject.keys(PATHS).forEach(key => Config[key] = Config.homePath + PATHS[key]);\\\\n\\\\n$.exports = Config;\\\"}]\",\"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!