epub2md 1.2.1 → 1.4.1

package/README.md

@@ -2,7 +2,18 @@
 
 Even though the package is primarily intended for CLI is to convert EPUB to Markdown, but it can be used programmatically.
 
-主要的目标是转换 epub 到 markdown，当然了也可以当做 epub 的解析器库使用.
+主要的目标是转换 epub 为 多个 markdown 文件，或者合并为 单个 markdown 文件，可以处理其中的远程图片资源；当然了也可以当做 epub 的解析器库使用.
+
+## Main Functions
+
+- **Convert EPUB to Markdown**: By default, convert and output numbered markdown files in sequence.
+- **Autocorrection**: Have option to Handle spaces and punctuation between Chinese and English as You Need.
+- **Merge Chapters**: Optionally merge all markdown files into a single Markdown file, Support link jumping.
+- **Image Processing**:
+  - Retain the original online image links.
+  - Download and localize online images (save remote images locally).
+- **View Information**: Easy to View the basic information, structure, and chapters of the EPUB.
+- **Extraction Function**: Dont need convert, just extract the useful contents of the EPUB file.
 
 ## Global Install for CLI
 
@@ -27,22 +38,41 @@ $ npm install @uxiew/epub2md
 ## CLI
 
 ```bash
-# show usage
+# Show usage help
 $ epub2md -h
 
 # Convert directly to markdown format
 $ epub2md ../../fixtures/zhihu.epub
-# or -m
+# or use -m
 $ epub2md -m ../../fixtures/zhihu.epub
 
-# Convert directly to markdown format with autocorrect to handle spacing between CJK and English words and Correct punctuations Only for command line use
+# Convert to markdown and automatically correct spaces and punctuation between Chinese and English (CLI only)
 $ epub2md -M ../../fixtures/zhihu.epub
 
-# show other info
-$ epub2md -u ../../fixtures/zhihu.epub
-$ epub2md -i ../../fixtures/zhihu.epub
-$ epub2md -S ../../fixtures/zhihu.epub
-$ epub2md -s ../../fixtures/zhihu.epub
+# Convert and directly generate a single merged markdown file (no intermediate files)
+$ epub2md -m ../../fixtures/zhihu.epub --merge
+# You can also use the epub file path as the first parameter directly
+$ epub2md ../../fixtures/zhihu.epub --merge
+
+# Use --merge=filename.md
+$ epub2md ../../fixtures/zhihu.epub --merge="merged-book.md"
+
+# By default, DONT downloaded. Basically, the images in the epub are already included, so there is no need to download. 
+# However, some epub image links are remote, You will see some warning，maybe they need to be downloaded.
+# Download and localize online images (download remote images to local) (need node > 18.0)
+$ epub2md ../../fixtures/zhihu.epub --localize
+
+# Download and localize online images, while merging all chapters into a single file
+$ epub2md ../../fixtures/zhihu.epub --merge --localize
+
+# Merge existing markdown files in a directory
+$ epub2md --merge ./path/to/markdown/dir
+
+# Show additional information
+$ epub2md -u ../../fixtures/zhihu.epub  # Extract epub
+$ epub2md -i ../../fixtures/zhihu.epub  # Show basic information
+$ epub2md -S ../../fixtures/zhihu.epub  # Show structure information
+$ epub2md -s ../../fixtures/zhihu.epub  # Show chapter information
 ```
 
 ## Usage

package/lib/bin/cli.cjs

@@ -6,59 +6,140 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Commands = void 0;
 var _args = _interopRequireDefault(require("args"));
-var _chalk = _interopRequireDefault(require("chalk"));
 var _nodeProcess = _interopRequireDefault(require("node:process"));
+var _nodeFs = _interopRequireDefault(require("node:fs"));
 var _parseEpub = _interopRequireDefault(require("../parseEpub.cjs"));
-var _convert = _interopRequireDefault(require("./convert.cjs"));
-var _beautyJson = require("beauty-json");
+var _convert = require("./convert.cjs");
+var _merge = require("./merge.cjs");
+var _logger = _interopRequireDefault(require("../logger.cjs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const name = "epub2md";
-var Commands = exports.Commands = /* @__PURE__ */(Commands2 => {
-  Commands2["markdown"] = "md";
-  Commands2["autocorrect"] = "ma";
-  Commands2["unzip"] = "unzip";
-  Commands2["info"] = "info";
-  Commands2["structure"] = "structure";
-  Commands2["sections"] = "sections";
-  return Commands2;
-})(Commands || {});
-const commands = [["md" /* markdown */, "convert the epub file to markdown format"], ["ma" /* autocorrect */, "convert the epub file to markdown format with autocorrect"], ["unzip" /* unzip */, "unzip epub file"], ["info" /* info */, "get epub file basic info"], ["structure" /* structure */, "get epub file structure"], ["sections" /* sections */, "get epub file sections"]];
-const DEFAULT_COMMAND = "md" /* markdown */;
-commands.forEach(cmd => _args.default.option(cmd[0], cmd[1]));
+const Commands = exports.Commands = {
+  convert: "convert",
+  autocorrect: "autocorrect",
+  unzip: "unzip",
+  info: "info",
+  structure: "structure",
+  sections: "sections",
+  merge: "merge",
+  localize: "localize"
+};
+const commands = [[Commands.convert, "convert the epub file to markdown format"], [Commands.autocorrect, "convert the epub file to markdown format with autocorrect"], [Commands.unzip, "unzip epub file"], [Commands.info, "get epub file basic info"], [Commands.structure, "get epub file structure"], [Commands.sections, "get epub file sections"], [Commands.merge, "merge all markdown files into a single file, can also specify output filename with --merge=filename.md"], [Commands.localize, "Retain the original online link and do not convert it to a local path", false]];
+const DEFAULT_COMMAND = Commands.convert;
+commands.forEach(cmd => _args.default.option(cmd[0], cmd[1], cmd[2]));
 const flags = _args.default.parse(_nodeProcess.default.argv, {
   name
 });
-commands.some(([cmd], i) => {
+const unprocessedArgs = _nodeProcess.default.argv.slice(2).filter(arg => !arg.startsWith("--") && !arg.startsWith("-"));
+if (unprocessedArgs.length > 0) {
+  flags[DEFAULT_COMMAND] = unprocessedArgs[0];
+}
+let hasRun = false;
+for (const cmd of [Commands.info, Commands.structure, Commands.sections]) {
   if (flags[cmd]) {
-    run(cmd);
-    return true;
+    if (typeof flags[cmd] !== "string") {
+      if (unprocessedArgs.length > 0) {
+        flags[cmd] = unprocessedArgs[0];
+      }
+    }
+    if (typeof flags[cmd] === "string") {
+      run(cmd);
+      hasRun = true;
+      break;
+    }
+  }
+}
+if (!hasRun && flags[Commands.unzip]) {
+  const epubPath = typeof flags[Commands.unzip] === "string" ? flags[Commands.unzip] : unprocessedArgs.length > 0 ? unprocessedArgs[0] : null;
+  if (epubPath) {
+    _logger.default.info("unzipping...");
+    new _convert.Converter(epubPath).run({
+      cmd: Commands.unzip,
+      // Use cmd to indicate unzip only
+      mergedFilename: void 0,
+      shouldMerge: false,
+      localize: false
+    }).then(outDir => {
+      _logger.default.info(`Unzip successful! output: ${outDir}`);
+    }).catch(error => {
+      _logger.default.error(error);
+    });
+    hasRun = true;
   } else {
-    if (i === commands.length - 1) {
-      if (_nodeProcess.default.argv[2]) {
-        flags[DEFAULT_COMMAND] = _nodeProcess.default.argv[2];
-        run(DEFAULT_COMMAND);
-        return true;
+    _logger.default.error("No valid epub file path provided for unzip command");
+  }
+}
+if (!hasRun) {
+  if (flags.merge && typeof flags.merge === "string" && flags.merge !== "") {
+    if (_nodeFs.default.existsSync(flags.merge) && _nodeFs.default.statSync(flags.merge).isDirectory()) {
+      _logger.default.info("merging markdown files in directory...");
+      (0, _merge.mergeMarkdowns)(flags.merge).then(outputPath => {
+        _logger.default.info(`Merging successful! Output file: ${outputPath}`);
+      }).catch(error => {
+        _logger.default.info(`Merging failed: ${error}`);
+      });
+      hasRun = true;
+    }
+  }
+  if (!hasRun) {
+    for (const cmd of [Commands.convert, Commands.autocorrect]) {
+      if (flags[cmd]) {
+        if (typeof flags[cmd] !== "string") {
+          if (unprocessedArgs.length > 0) {
+            flags[cmd] = unprocessedArgs[0];
+          }
+        }
+        run(cmd);
+        hasRun = true;
+        break;
       }
+    }
+    if (!hasRun && unprocessedArgs.length > 0) {
+      run(DEFAULT_COMMAND);
+    } else if (!hasRun) {
       _args.default.showHelp();
     }
   }
-});
+}
 function run(cmd) {
-  const epubPath = flags["md" /* markdown */] || flags["ma" /* autocorrect */] || flags["unzip" /* unzip */];
-  if (epubPath) {
-    console.log(_chalk.default.blueBright(`[${name}]: converting${cmd === "ma" /* autocorrect */ ? " with AutoCorrect" : ""}...`));
-    new _convert.default({
-      eubPath: epubPath,
-      cmd
-    }).run(flags["unzip" /* unzip */]).then(outDir => {
-      console.log(_chalk.default.greenBright(`[${name}]: success! output: ${outDir}`));
+  if (cmd === Commands.convert || cmd === Commands.autocorrect) {
+    const epubPath = typeof flags[cmd] === "string" ? flags[cmd] : null;
+    if (!epubPath) {
+      _logger.default.error("No valid epub file path provided");
+      return;
+    }
+    _logger.default.info(`converting${cmd === Commands.autocorrect ? " with autocorrect" : ""}${flags[Commands.merge] ? " and merging" : ""}...`);
+    const shouldMerge = flags.merge === true || typeof flags.merge === "string" && flags.merge !== "";
+    let mergedFilename;
+    if (typeof flags.merge === "string" && flags.merge !== "") {
+      mergedFilename = flags.merge;
+    }
+    const localize = flags.localize === true;
+    new _convert.Converter(epubPath).run({
+      cmd,
+      mergedFilename,
+      shouldMerge,
+      localize
+    }).then(outDir => {
+      if (shouldMerge) {
+        _logger.default.info(`Merging successful! Output file: ${outDir}`);
+      } else {
+        _logger.default.info(`Conversion successful! output: ${outDir}`);
+      }
+    }).catch(error => {
+      _logger.default.error(error);
     });
     return;
   }
-  (0, _parseEpub.default)(flags[cmd]).then(res => {
-    console.log(_chalk.default.greenBright(`[${name}]: This book ${cmd}:`));
-    _beautyJson.json.log(res[cmd]);
-  }).catch(error => {
-    console.log(_chalk.default.red(error));
-  });
+  const cmdPath = flags[cmd];
+  if (typeof cmdPath === "string") {
+    (0, _parseEpub.default)(cmdPath).then(res => {
+      _logger.default.success(`This book ${cmd}:`);
+      _logger.default.json(res[cmd]);
+    }).catch(error => {
+      _logger.default.error(error);
+    });
+  } else {
+    _logger.default.error(`Path must be a string, got ${typeof cmdPath}`);
+  }
 }

package/lib/bin/convert.cjs

@@ -3,11 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
+exports.Converter = void 0;
 var _nodePath = require("node:path");
 var _nodeFs = require("node:fs");
+var _logger = _interopRequireDefault(require("../logger.cjs"));
 var _writeFileSafe = require("write-file-safe");
-var _chalk = _interopRequireDefault(require("chalk"));
 var _parseEpub = _interopRequireDefault(require("../parseEpub.cjs"));
 var _helper = require("./helper.cjs");
 var _utils = require("../utils.cjs");
@@ -16,165 +16,301 @@ var _cli = require("./cli.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class Converter {
   epub;
-  // epub parser result
+  // epub parser object
   epubFilePath;
   // current epub 's path
-  cmd;
-  // current using command flag
-  MD_FILE_EXT = ".md";
-  // out file extname
   outDir;
   // epub 's original directory to save markdown files
+  mergedFilename;
+  // The merged file name
+  // include images/html/css/js in the epub file
   structure = [];
   // epub dir structure
-  constructor({
-    eubPath,
-    cmd
-  }) {
-    this.epubFilePath = eubPath;
-    this.cmd = cmd;
-    this.outDir = (0, _nodePath.dirname)(eubPath);
+  cmd = "convert";
+  // current using command flag
+  shouldMerge = false;
+  // Whether to directly generate the merged file
+  localize = false;
+  // Whether to retain the original online image link
+  IMAGE_DIR = "images";
+  // The directory to save images
+  MD_FILE_EXT = ".md";
+  // out file extname
+  /**
+   * Constructor
+   * @param epubPath - The path to the EPUB file
+   */
+  constructor(epubPath) {
+    this.epubFilePath = epubPath;
+    this.outDir = (0, _nodePath.dirname)(epubPath);
     if (!(0, _nodeFs.existsSync)(this.outDir)) (0, _nodeFs.mkdirSync)(this.outDir);
   }
-  checkFileType(filepath) {
-    let isImage,
-      isCSS,
-      isHTML = false;
-    const ext = (0, _nodePath.extname)(filepath);
-    if (",.jpg,.jpeg,.png,.gif,.webp,.svg".includes(ext)) isImage = true;
-    if (",.css".includes(ext)) isCSS = true;
-    if (".htm,.html,.xhtml".includes(ext)) isHTML = true;
+  clearOutpath({
+    id,
+    outpath,
+    orderLabel
+  }) {
+    function _matchNav(id2, tocItems) {
+      if (Array.isArray(tocItems)) for (let i = 0; i < tocItems.length; i++) {
+        const item = tocItems[i];
+        if (item.sectionId === id2) {
+          return item;
+        }
+        if (item.children) {
+          const childMatch = _matchNav(id2, item.children);
+          if (childMatch) {
+            return childMatch;
+          }
+        }
+      }
+      return void 0;
+    }
+    const nav = _matchNav(id, this.epub.structure);
+    const fileName = (0, _helper.getClearFilename)(nav ? nav.name + this.MD_FILE_EXT : (0, _nodePath.basename)(outpath));
+    const outDir = (0, _nodePath.dirname)(outpath);
     return {
-      isImage,
-      isCSS,
-      isHTML
+      fileName,
+      outDir,
+      outPath: (0, _nodePath.join)(outDir, orderLabel + "-" + fileName)
     };
   }
-  resolveHTMLId(fileName) {
-    return fileName.replace(/\.x?html?(?:.*)/, "");
-  }
-  // 文件名处理
-  getCleanFileName(fileName, ext = "") {
-    return (0, _utils.sanitizeFileName)(fileName).trim().replace(/\s/g, "_") + ext;
-  }
   /**
   * Make a path，and normalize assets's path. normally markdowns dont need those css/js files, So i skip them
   * @return these target file's path will be created，like "xxx/xxx.md","xxx/images"
   */
-  _makePath(filepath) {
+  parseFileInfo(filepath) {
     const {
       isImage,
       isHTML
-    } = this.checkFileType(filepath);
-    if (!isImage && !isHTML) return "";
-    const fileName = (0, _nodePath.basename)(filepath);
-    return (0, _nodePath.join)(this.outDir, isImage ? "images" : "", isHTML ? this.resolveHTMLId(fileName) + this.MD_FILE_EXT : fileName);
+    } = (0, _helper.checkFileType)(filepath);
+    const name2 = (0, _nodePath.basename)(filepath);
+    const path = !isImage && !isHTML ? (0, _nodePath.join)(this.outDir, "static", isHTML ? (0, _helper.resolveHTMLId)(name2) + this.MD_FILE_EXT : name2) : (0, _nodePath.join)(this.outDir, isImage ? this.IMAGE_DIR : "", isHTML ? (0, _helper.resolveHTMLId)(name2) + this.MD_FILE_EXT : name2);
+    return {
+      // html => md
+      type: isHTML ? "md" : isImage ? "img" : "",
+      name: name2,
+      path
+    };
   }
+  /**
+   * Retrieves and processes the manifest of an EPUB file.
+   *
+   * @param unzip - Optional flag to indicate whether to simply unzip the file contents
+   * @returns Populates the structure array with manifest items, either unzipped or converted
+   *
+   * This method parses the EPUB file, extracts its manifest, and creates a structure
+   * representing the file contents. When unzip is false, it skips certain files like
+   * the NCX file and title page, and generates appropriate output paths for other files.
+   */
   async getManifest(unzip) {
     this.epub = await (0, _parseEpub.default)(this.epubFilePath, {
       convertToMarkdown: _helper.convertHTML
     });
     this.outDir = this.epubFilePath.replace(".epub", "");
-    this.epub.getManifest().forEach(({
+    let num = 0;
+    const padding = Math.floor(Math.log10(this.epub?.sections?.length ?? 0));
+    for (const {
       href: filepath,
       id
-    }) => {
-      let outpath;
+    } of this.epub.getManifest()) {
+      let outpath = "",
+        type = "";
       if (unzip) outpath = (0, _nodePath.join)(this.outDir, filepath);else {
-        if (filepath.endsWith("ncx") || id === "titlepage") return;
-        outpath = this._makePath(filepath);
+        if (filepath.endsWith("ncx") || id === "titlepage") continue;
+        const file = this.parseFileInfo(filepath);
+        outpath = file.path;
+        type = file.type;
       }
-      if (outpath !== "") this.structure.push({
-        id,
-        outpath,
-        filepath
-      });
+      if (type !== "") {
+        this.structure.push({
+          // current only label markdown file
+          orderLabel: type === "md" ? (num++, ("0".repeat(padding) + num).slice(-(padding + 1))) : "",
+          id,
+          type,
+          outpath,
+          filepath
+        });
+      }
+    }
+  }
+  /**
+   * Download remote images to the local images directory
+   */
+  async downloadImage(url, dest) {
+    if ((0, _nodeFs.existsSync)(dest)) return;
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to download image: ${url}`);
+    const arrayBuffer = await res.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    (0, _writeFileSafe.writeFileSync)(dest, buffer, {
+      overwrite: true
     });
   }
   /**
-  * Try to obtain a friendly output filename.
-  */
-  _getFileData(structure) {
+   * 本地化 markdown 内容中的所有 http/https 图片链接
+   */
+  async localizeImages(links, outDir) {
+    if (!(0, _nodeFs.existsSync)(outDir)) (0, _nodeFs.mkdirSync)(outDir);
+    const downloadTasks = [];
+    for (const link of links) {
+      const imgName = (0, _nodePath.basename)(link.split("?")[0]);
+      const localPath = (0, _nodePath.join)(outDir, imgName);
+      downloadTasks.push(this.downloadImage(link, localPath));
+    }
+    if (downloadTasks.length) await Promise.all(downloadTasks);
+  }
+  async getFileDataAsync(structure, handleContent) {
     let {
       id,
+      type,
       filepath,
-      outpath
+      outpath,
+      orderLabel
     } = structure;
-    let content = "";
+    let content = "",
+      links = [];
     const needAutoCorrect = this.cmd === _cli.Commands.autocorrect;
-    if ((0, _nodePath.extname)(outpath) === ".md") {
-      let _matchNav = function (tocItems, id2) {
-        if (Array.isArray(tocItems)) for (let i = 0; i < tocItems.length; i++) {
-          const item = tocItems[i];
-          if (item.sectionId === id2) {
-            return item;
-          }
-          if (item.children) {
-            const childMatch = _matchNav(item.children, id2);
-            if (childMatch) {
-              return childMatch;
-            }
-          }
-        }
-        return void 0;
-      };
-      content = this.epub?.getSection(id)?.toMarkdown();
-      const nav = _matchNav(this.epub?.structure, id);
-      const cleanFilename = this.getCleanFileName(nav ? nav.name + this.MD_FILE_EXT : (0, _nodePath.basename)(outpath));
-      outpath = (0, _nodePath.join)((0, _nodePath.dirname)(outpath), cleanFilename);
-      content = (0, _helper.fixLinkPath)(content, (link, text) => {
-        if (text) {
+    if (type === "md") {
+      const section = this.epub?.getSection(id);
+      if (section) {
+        content = section.toMarkdown();
+      }
+      const {
+        outPath,
+        fileName
+      } = this.clearOutpath(structure);
+      outpath = outPath;
+      const resLinks = [];
+      const linkStartSep = this.shouldMerge ? "#" : "./";
+      content = (0, _helper.fixLinkPath)(content, (link, isText) => {
+        if (isText) {
           const {
-            hash,
+            hash = "",
             url
-          } = (0, _parseLink.default)(link);
+          } = (0, _parseLink.default)(link, true);
           if (link.startsWith("#")) {
-            return "./" + cleanFilename + link;
+            return linkStartSep + this.shouldMerge ? id : fileName + link;
           }
-          link = this.resolveHTMLId((0, _nodePath.basename)(url));
-          const anav = (0, _utils.findRealPath)(link, this.epub?.structure) || {
-            name: link
+          link = (0, _helper.resolveHTMLId)((0, _nodePath.basename)(url));
+          const sectionId = this.epub.getItemId(url);
+          const internalNav = (0, _utils.matchTOC)(sectionId, this.epub?.structure) || {
+            name: link,
+            sectionId: (0, _helper.getClearFilename)((0, _nodePath.basename)(link))
           };
-          return "./" + this.getCleanFileName((0, _nodePath.extname)(anav.name) ? anav.name : anav.name + this.MD_FILE_EXT) + `${hash ? "#" + hash : ""}`;
+          let validPath = (0, _helper.getClearFilename)((0, _nodePath.extname)(internalNav.name) ? internalNav.name : internalNav.name + this.MD_FILE_EXT);
+          for (const sfile of this.structure) {
+            if (sectionId === sfile.id) {
+              validPath = (0, _nodePath.basename)(this.clearOutpath(sfile).outPath);
+              break;
+            }
+          }
+          const toId = this.epub.getItemId((0, _nodePath.join)((0, _nodePath.dirname)(filepath), url));
+          links.push({
+            url,
+            hash,
+            id: internalNav.sectionId,
+            toId
+          });
+          return this.shouldMerge ? linkStartSep + toId + (hash ? "#" + hash : "") : linkStartSep + validPath + `${hash ? "#" + hash : ""}`;
         } else {
-          return "./images/" + (0, _nodePath.basename)(link);
+          if (link.startsWith("http")) {
+            resLinks.push(link);
+          }
+          return "./" + this.IMAGE_DIR + "/" + (0, _nodePath.basename)(link);
         }
       });
+      if (this.localize) {
+        try {
+          this.localizeImages(resLinks, (0, _nodePath.join)(this.outDir, this.IMAGE_DIR));
+        } catch (error) {
+          _logger.default.error("Failed to localize the image!", error);
+        }
+      } else if (resLinks.length > 0) {
+        _logger.default.warn("Remote images are detected, you can set --localize to true to localize the remote images");
+      }
       content = needAutoCorrect ? require("autocorrect-node").format(content) : content;
     } else {
       content = this.epub.resolve(filepath).asNodeBuffer();
     }
     return {
+      id,
+      type,
+      filepath,
       content,
+      links,
       outFilePath: outpath
     };
   }
-  async run(unzip) {
-    await this.getManifest(unzip);
-    let num = 1,
-      filterPool = {};
-    const padding = Math.floor(Math.log10(this.structure.length));
-    this.structure.forEach(s => {
+  /**
+   * Runs the conversion process for an EPUB file.
+   *
+   * @param RunOptions - Configuration options or boolean (backward compatibility)
+   * @returns A promise resolving to the output directory or the result of generating a merged file
+   */
+  async run(options) {
+    const isUnzipOnly = options?.cmd === "unzip";
+    if (options) {
+      this.cmd = options.cmd;
+      this.shouldMerge = options.shouldMerge;
+      this.localize = options.localize;
+      this.mergedFilename = options.mergedFilename;
+    }
+    await this.getManifest(isUnzipOnly);
+    if (this.shouldMerge && !isUnzipOnly) {
+      return this.generateMergedFile();
+    }
+    let num = 1;
+    for (const s of this.structure) {
       const {
+        type,
         outFilePath,
         content
-      } = this._getFileData(s);
-      let numberedOutFilePath = null;
-      if (content.toString() === "") return;
-      if (!filterPool[outFilePath] && (0, _nodePath.basename)(outFilePath).endsWith(".md")) {
-        const parsedPath = (0, _nodePath.parse)(outFilePath);
-        numberedOutFilePath = (0, _nodePath.format)({
-          ...parsedPath,
-          base: `${("0".repeat(padding) + num).slice(-(padding + 1))}-${parsedPath.base}`
-        });
-        console.log(_chalk.default.yellow(`${num++}: [${(0, _nodePath.basename)(numberedOutFilePath)}]`));
+      } = await this.getFileDataAsync(s);
+      if (content.toString() === "") continue;
+      if (type === "md") {
+        _logger.default.success(`${num++}: [${(0, _nodePath.basename)(outFilePath)}]`);
       }
-      filterPool[outFilePath] = true;
-      (0, _writeFileSafe.writeFileSync)(numberedOutFilePath ?? outFilePath, content, {
+      (0, _writeFileSafe.writeFileSync)(outFilePath, content, {
         overwrite: true
       });
-    });
+    }
     return this.outDir;
   }
+  /**
+   * Directly generate a single merged Markdown file
+   */
+  async generateMergedFile() {
+    let num = 1,
+      mergedContent = "";
+    for (const s of this.structure) {
+      let {
+        id,
+        filepath,
+        outFilePath,
+        content
+      } = await this.getFileDataAsync(s);
+      const {
+        isHTML
+      } = (0, _helper.checkFileType)(filepath);
+      if (isHTML) {
+        content = `<a role="toc_link" id="${id}"></a>
+` + content;
+      }
+      if ((0, _nodePath.extname)(outFilePath) === ".md" && content.toString() !== "") {
+        num++;
+        mergedContent += content.toString() + "\n\n---\n\n";
+        _logger.default.success(`${num}: [${(0, _nodePath.basename)(outFilePath)}]`);
+      } else if ((0, _nodePath.extname)(outFilePath) !== ".md") {
+        (0, _writeFileSafe.writeFileSync)(outFilePath, content, {
+          overwrite: true
+        });
+      }
+    }
+    const outputPath = (0, _nodePath.join)(this.outDir, this.mergedFilename || `${(0, _nodePath.basename)(this.outDir)}-merged.md`);
+    (0, _writeFileSafe.writeFileSync)(outputPath, mergedContent, {
+      overwrite: true
+    });
+    return outputPath;
+  }
 }
-module.exports = Converter;
+exports.Converter = Converter;