wp-epub-gen 0.2.3 → 0.4.0

package/build/index.cjs

@@ -0,0 +1,1279 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const os = require("os");
+const path = require("path");
+const url = require("url");
+const uuid = require("uuid");
+const cheerio = require("cheerio");
+const diacritics = require("diacritics");
+const uslug = require("uslug");
+const archiver = require("archiver");
+const fs$1 = require("fs-extra");
+const request = require("superagent");
+const fs = require("fs");
+const util = require("util");
+const ejs = require("ejs");
+const entities = require("entities");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const cheerio__namespace = /* @__PURE__ */ _interopNamespaceDefault(cheerio);
+const entities__namespace = /* @__PURE__ */ _interopNamespaceDefault(entities);
+const errors = {
+  no_output_path: "No output path!",
+  no_title: "Title is required.",
+  no_content: "Content is required."
+};
+class GlobalLogger {
+  constructor() {
+    this.customLogger = null;
+  }
+  /**
+   * 获取 Logger 单例实例
+   */
+  static getInstance() {
+    if (!GlobalLogger.instance) {
+      GlobalLogger.instance = new GlobalLogger();
+    }
+    return GlobalLogger.instance;
+  }
+  /**
+   * 设置自定义 logger
+   * @param logger 自定义 logger 实例
+   */
+  setLogger(logger2) {
+    this.customLogger = logger2;
+  }
+  /**
+   * 获取当前使用的 logger
+   */
+  getLogger() {
+    return this.customLogger || {
+      log: (msg) => console.log(msg),
+      info: (msg) => console.info(msg),
+      error: (msg) => console.error(msg),
+      warn: (msg) => console.warn(msg)
+    };
+  }
+  /**
+   * 输出普通日志
+   */
+  log(msg) {
+    this.getLogger().log(msg);
+  }
+  /**
+   * 输出信息日志
+   */
+  info(msg) {
+    this.getLogger().info(msg);
+  }
+  /**
+   * 输出错误日志
+   */
+  error(msg) {
+    this.getLogger().error(msg);
+  }
+  /**
+   * 输出警告日志
+   */
+  warn(msg) {
+    this.getLogger().warn(msg);
+  }
+}
+const logger = GlobalLogger.getInstance();
+function safeFineName(name) {
+  return name.replace(/[/\\?%*:|"<>\t\r\n]/g, "_");
+}
+const mimeModule$1 = require("mime/lite");
+const mime$1 = mimeModule$1.default || mimeModule$1;
+const ALLOWED_ATTRIBUTES = [
+  "about",
+  "accesskey",
+  "alt",
+  "aria-activedescendant",
+  "aria-atomic",
+  "aria-autocomplete",
+  "aria-busy",
+  "aria-checked",
+  "aria-controls",
+  "aria-describedat",
+  "aria-describedby",
+  "aria-disabled",
+  "aria-dropeffect",
+  "aria-expanded",
+  "aria-flowto",
+  "aria-grabbed",
+  "aria-haspopup",
+  "aria-hidden",
+  "aria-invalid",
+  "aria-label",
+  "aria-labelledby",
+  "aria-level",
+  "aria-live",
+  "aria-multiline",
+  "aria-multiselectable",
+  "aria-orientation",
+  "aria-owns",
+  "aria-posinset",
+  "aria-pressed",
+  "aria-readonly",
+  "aria-relevant",
+  "aria-required",
+  "aria-selected",
+  "aria-setsize",
+  "aria-sort",
+  "aria-valuemax",
+  "aria-valuemin",
+  "aria-valuenow",
+  "aria-valuetext",
+  "class",
+  "colspan",
+  "content",
+  // 去除重复
+  "contenteditable",
+  "contextmenu",
+  "datatype",
+  "dir",
+  "draggable",
+  "dropzone",
+  "epub:prefix",
+  "epub:type",
+  "hidden",
+  "href",
+  "hreflang",
+  "id",
+  // 去除重复
+  "inlist",
+  "itemid",
+  "itemref",
+  "itemscope",
+  "itemtype",
+  "lang",
+  "media",
+  "ns1:type",
+  "ns2:alphabet",
+  "ns2:ph",
+  "onabort",
+  "onblur",
+  "oncanplay",
+  "oncanplaythrough",
+  "onchange",
+  "onclick",
+  "oncontextmenu",
+  "ondblclick",
+  "ondrag",
+  "ondragend",
+  "ondragenter",
+  "ondragleave",
+  "ondragover",
+  "ondragstart",
+  "ondrop",
+  "ondurationchange",
+  "onemptied",
+  "onended",
+  "onerror",
+  "onfocus",
+  "oninput",
+  "oninvalid",
+  "onkeydown",
+  "onkeypress",
+  "onkeyup",
+  "onload",
+  "onloadeddata",
+  "onloadedmetadata",
+  "onloadstart",
+  "onmousedown",
+  "onmousemove",
+  "onmouseout",
+  "onmouseover",
+  "onmouseup",
+  "onmousewheel",
+  "onpause",
+  "onplay",
+  "onplaying",
+  "onprogress",
+  "onratechange",
+  "onreadystatechange",
+  "onreset",
+  "onscroll",
+  "onseeked",
+  "onseeking",
+  "onselect",
+  "onshow",
+  "onstalled",
+  "onsubmit",
+  "onsuspend",
+  "ontimeupdate",
+  "onvolumechange",
+  "onwaiting",
+  "prefix",
+  "property",
+  "rel",
+  "resource",
+  "rev",
+  "role",
+  "rowspan",
+  "spellcheck",
+  "src",
+  "style",
+  "tabindex",
+  "target",
+  "title",
+  // 去除重复
+  "type",
+  "typeof",
+  "vocab",
+  "xml:base",
+  "xml:lang",
+  "xml:space"
+];
+const ALLOWED_XHTML11_TAGS = [
+  "a",
+  "abbr",
+  "acronym",
+  "address",
+  "applet",
+  "b",
+  "bar",
+  "basefont",
+  "bdo",
+  "big",
+  "blockquote",
+  "br",
+  "caption",
+  "center",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "dd",
+  "del",
+  "dfn",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "font",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "hr",
+  "i",
+  "iframe",
+  "img",
+  "ins",
+  "kbd",
+  "li",
+  "map",
+  "noscript",
+  "ns:svg",
+  "object",
+  // 去除重复
+  "ol",
+  "p",
+  "param",
+  "pre",
+  "q",
+  "s",
+  "samp",
+  "script",
+  "small",
+  "span",
+  "strike",
+  "strong",
+  "sub",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "tt",
+  "u",
+  "ul",
+  "var"
+];
+const ALLOWED_ATTRIBUTES_SET = new Set(ALLOWED_ATTRIBUTES);
+const ALLOWED_XHTML11_TAGS_SET = new Set(ALLOWED_XHTML11_TAGS);
+const SELF_CLOSING_TAGS = /* @__PURE__ */ new Set(["img", "br", "hr"]);
+function initializeChapterInfo(content, index, epubConfigs) {
+  const chapter = { ...content };
+  let { filename } = chapter;
+  if (!filename) {
+    let titleSlug = uslug(diacritics.remove(chapter.title || "no title"));
+    titleSlug = titleSlug.replace(/[/\\]/g, "_");
+    chapter.href = `${index}_${titleSlug}.xhtml`;
+    chapter.filePath = path.join(epubConfigs.dir, "OEBPS", chapter.href);
+  } else {
+    filename = safeFineName(filename);
+    const is_xhtml = filename.endsWith(".xhtml");
+    chapter.href = is_xhtml ? filename : `${filename}.xhtml`;
+    if (is_xhtml) {
+      chapter.filePath = path.join(epubConfigs.dir, "OEBPS", filename);
+    } else {
+      chapter.filePath = path.join(epubConfigs.dir, "OEBPS", `${filename}.xhtml`);
+    }
+  }
+  chapter.id = `item_${index}`;
+  chapter.dir = path.dirname(chapter.filePath);
+  chapter.excludeFromToc = chapter.excludeFromToc || false;
+  chapter.beforeToc = chapter.beforeToc || false;
+  return chapter;
+}
+function normalizeAuthorInfo(chapter) {
+  if (chapter.author && typeof chapter.author === "string") {
+    chapter.author = [chapter.author];
+  } else if (!chapter.author || !Array.isArray(chapter.author)) {
+    chapter.author = [];
+  }
+}
+function getAllowedAttributes() {
+  return ALLOWED_ATTRIBUTES;
+}
+function getAllowedXhtml11Tags() {
+  return ALLOWED_XHTML11_TAGS;
+}
+function loadAndProcessHtml(data) {
+  if (!data || typeof data !== "string") {
+    throw new Error("Invalid HTML data: data must be a non-empty string");
+  }
+  const trimmedData = data.trim();
+  if (trimmedData.length === 0) {
+    throw new Error("Invalid HTML data: data cannot be empty or whitespace only");
+  }
+  try {
+    let $ = cheerio__namespace.load(trimmedData, {
+      xml: {
+        lowerCaseTags: true,
+        recognizeSelfClosing: true
+      }
+    });
+    const body = $("body");
+    if (body.length) {
+      const html = body.html();
+      if (html) {
+        $ = cheerio__namespace.load(html, {
+          xml: {
+            lowerCaseTags: true,
+            recognizeSelfClosing: true
+          }
+        });
+      }
+    }
+    return $;
+  } catch (error) {
+    throw new Error(
+      `Failed to parse HTML content: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function processHtmlElements($, allowedAttributes, allowedXhtml11Tags, epubConfigs, index) {
+  const allowedAttrsSet = ALLOWED_ATTRIBUTES_SET;
+  const allowedTagsSet = ALLOWED_XHTML11_TAGS_SET;
+  const selfClosingTags = SELF_CLOSING_TAGS;
+  $($("*").get().reverse()).each(function(elemIndex, elem) {
+    const attrs = elem.attribs || {};
+    const $elem = $(elem);
+    const tagName = elem.name;
+    if (selfClosingTags.has(tagName)) {
+      if (tagName === "img" && !$elem.attr("alt")) {
+        $elem.attr("alt", "image-placeholder");
+      }
+    }
+    const attrsToRemove = [];
+    for (const [attrName] of Object.entries(attrs)) {
+      if (allowedAttrsSet.has(attrName)) {
+        if (attrName === "type" && tagName !== "script") {
+          attrsToRemove.push(attrName);
+        }
+      } else {
+        attrsToRemove.push(attrName);
+      }
+    }
+    for (const attrName of attrsToRemove) {
+      $elem.removeAttr(attrName);
+    }
+    if (epubConfigs.version === 2) {
+      if (!allowedTagsSet.has(tagName)) {
+        if (epubConfigs.verbose) {
+          logger.warn(
+            `Warning (content[${index}]): ${tagName} tag isn't allowed on EPUB 2/XHTML 1.1 DTD.`
+          );
+        }
+        const child = $elem.html();
+        $elem.replaceWith($("<div>" + child + "</div>"));
+      }
+    }
+  });
+}
+function processImages($, chapter, epubConfigs) {
+  $("img").each((index, elem) => {
+    const url2 = $(elem).attr("src") || "";
+    if (!url2 || url2.trim().length === 0) {
+      logger.warn(`Image at index ${index} in chapter has empty src attribute, removing element`);
+      $(elem).remove();
+      return;
+    }
+    const trimmedUrl = url2.trim();
+    try {
+      if (!trimmedUrl.match(/^(https?:\/\/|data:|\.\/|\/)/)) {
+        logger.warn(`Image URL "${trimmedUrl}" appears to be invalid, but processing anyway`);
+      }
+    } catch (error) {
+      logger.error(`Error validating image URL "${trimmedUrl}": ${error}`);
+    }
+    const image = epubConfigs.images.find((el) => el.url === trimmedUrl);
+    let id;
+    let extension;
+    if (image) {
+      id = image.id;
+      extension = image.extension;
+    } else {
+      id = uuid.v4();
+      let mediaType = "";
+      try {
+        const cleanUrl = trimmedUrl.replace(/\?.*/, "");
+        mediaType = mime$1.getType(cleanUrl) || "";
+        if (!mediaType) {
+          const urlExtension = cleanUrl.split(".").pop()?.toLowerCase();
+          if (urlExtension && ["jpg", "jpeg", "png", "gif", "webp", "svg"].includes(urlExtension)) {
+            mediaType = `image/${urlExtension === "jpg" ? "jpeg" : urlExtension}`;
+            logger.warn(
+              `Could not determine MIME type for "${trimmedUrl}", inferred as "${mediaType}"`
+            );
+          } else {
+            logger.warn(
+              `Could not determine MIME type for "${trimmedUrl}", defaulting to image/jpeg`
+            );
+            mediaType = "image/jpeg";
+          }
+        }
+      } catch (error) {
+        logger.error(`Error determining MIME type for "${trimmedUrl}": ${error}`);
+        mediaType = "image/jpeg";
+      }
+      try {
+        extension = mime$1.getExtension(mediaType) || "jpg";
+      } catch (error) {
+        logger.error(`Error getting extension for MIME type "${mediaType}": ${error}`);
+        extension = "jpg";
+      }
+      const dir = chapter.dir || "";
+      const img = { id, url: trimmedUrl, dir, mediaType, extension };
+      epubConfigs.images.push(img);
+      if (epubConfigs.verbose) {
+        logger.info(`Added image: ${trimmedUrl} -> images/${id}.${extension} (${mediaType})`);
+      }
+    }
+    try {
+      $(elem).attr("src", `images/${id}.${extension}`);
+    } catch (error) {
+      logger.error(`Error setting src attribute for image ${id}: ${error}`);
+      $(elem).remove();
+    }
+  });
+}
+function extractAndCleanHtmlContent($, originalData) {
+  let data;
+  if ($("body").length) {
+    data = $("body").html() || "";
+  } else {
+    data = $.root().html() || "";
+  }
+  if (!originalData) {
+    return data.replace(
+      /<(br|hr|img|input|meta|area|base|col|embed|link|source|track|wbr)([^>]*?)><\/\1>/gi,
+      "<$1$2/>"
+    ).replace(
+      new RegExp("<(br|hr|img|input|meta|area|base|col|embed|link|source|track|wbr)([^>]*?)(?<!\\/)>", "gi"),
+      "<$1$2/>"
+    );
+  }
+  const entityMap = /* @__PURE__ */ new Map();
+  const entityRegex = /&[a-zA-Z][a-zA-Z0-9]*;|&#[0-9]+;|&#x[0-9a-fA-F]+;/g;
+  const matches = Array.from(originalData.matchAll(entityRegex));
+  let processedOriginal = originalData;
+  const timestamp = Date.now();
+  const randomId = Math.random().toString(36).substring(2, 8);
+  const placeholderPrefix = `__ENTITY_${timestamp}_${randomId}_`;
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const match = matches[i];
+    const placeholder = `${placeholderPrefix}${i}__`;
+    entityMap.set(placeholder, match[0]);
+    processedOriginal = processedOriginal.substring(0, match.index) + placeholder + processedOriginal.substring(match.index + match[0].length);
+  }
+  const $temp = cheerio__namespace.load(processedOriginal, {
+    xmlMode: false
+  });
+  let tempData;
+  if ($temp("body").length) {
+    tempData = $temp("body").html() || "";
+  } else {
+    tempData = $temp.root().html() || "";
+  }
+  for (const [placeholder, entity] of entityMap) {
+    tempData = tempData.replace(new RegExp(placeholder, "g"), entity);
+  }
+  return tempData.replace(
+    /<(br|hr|img|input|meta|area|base|col|embed|link|source|track|wbr)([^>]*?)><\/\1>/gi,
+    "<$1$2/>"
+  ).replace(
+    new RegExp("<(br|hr|img|input|meta|area|base|col|embed|link|source|track|wbr)([^>]*?)(?<!\\/)>", "gi"),
+    "<$1$2/>"
+  );
+}
+function processChildrenChapters(chapter, index, epubConfigs) {
+  if (Array.isArray(chapter.children)) {
+    chapter.children = chapter.children.map(
+      (content, idx) => parseContent(content, `${index}_${idx}`, epubConfigs)
+    );
+  }
+}
+function parseContent(content, index, epubConfigs) {
+  if (!content) {
+    throw new Error("Content cannot be null or undefined");
+  }
+  if (!content.data) {
+    logger.warn(`Chapter at index ${index} has no data, using empty string`);
+    content.data = "";
+  }
+  const chapter = initializeChapterInfo(content, index, epubConfigs);
+  normalizeAuthorInfo(chapter);
+  const allowedAttributes = getAllowedAttributes();
+  const allowedXhtml11Tags = getAllowedXhtml11Tags();
+  if (!chapter.data || chapter.data.trim().length === 0) {
+    logger.warn(`Chapter at index ${index} has empty data, setting empty content`);
+    chapter.data = "";
+  } else {
+    let $;
+    try {
+      $ = loadAndProcessHtml(chapter.data);
+    } catch (error) {
+      logger.error(`Failed to process HTML for chapter ${index}: ${error}`);
+      $ = cheerio__namespace.load(`<div>${chapter.data}</div>`);
+    }
+    processHtmlElements($, allowedAttributes, allowedXhtml11Tags, epubConfigs, index);
+    processImages($, chapter, epubConfigs);
+    chapter.data = extractAndCleanHtmlContent($, content.data);
+  }
+  processChildrenChapters(chapter, index, epubConfigs);
+  return chapter;
+}
+util.promisify(fs.readFile);
+const writeFile = util.promisify(fs.writeFile);
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36";
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function fileIsStable(filename, max_wait = 3e4) {
+  const start_time = (/* @__PURE__ */ new Date()).getTime();
+  let last_size = fs.statSync(filename).size;
+  while ((/* @__PURE__ */ new Date()).getTime() - start_time <= max_wait) {
+    await wait(1e3);
+    const size = fs.statSync(filename).size;
+    if (size === last_size) return true;
+    last_size = size;
+  }
+  return false;
+}
+function simpleMinifier(xhtml) {
+  xhtml = xhtml.replace(/\s+<\/a>/gi, "</a>").replace(/\n\s+</g, "\n<").replace(/\n+/g, "\n");
+  return xhtml;
+}
+const downloadImage = async (epubData, options) => {
+  const { url: url2 } = options;
+  const { log } = epubData;
+  const epub_dir = epubData.dir;
+  if (!url2) {
+    return;
+  }
+  const image_dir = path.join(epub_dir, "OEBPS", "images");
+  fs$1.ensureDirSync(image_dir);
+  const filename = path.join(image_dir, options.id + "." + options.extension);
+  if (url2.startsWith("file://") || url2.startsWith("/")) {
+    let aux_path = url2.replace(/^file:\/\//i, "");
+    try {
+      aux_path = decodeURIComponent(aux_path);
+    } catch {
+      log(`[URL Decode Warning] Failed to decode path: ${aux_path}`);
+    }
+    if (process.platform === "win32") {
+      if (aux_path.match(/^\/[a-zA-Z]:/)) {
+        aux_path = aux_path.replace(/^\//, "");
+      }
+    }
+    log(`[Copy 1] '${aux_path}' to '${filename}'`);
+    if (fs$1.existsSync(aux_path)) {
+      try {
+        fs$1.copySync(aux_path, filename);
+      } catch (e) {
+        log("[Copy 1 Error] " + e.message);
+      }
+    } else {
+      log(`[Copy 1 Fail] '${url2}' not exists!`);
+    }
+    return;
+  }
+  let requestAction;
+  if (url2.startsWith("http")) {
+    requestAction = request.get(url2).set({ "User-Agent": USER_AGENT });
+    requestAction.pipe(fs$1.createWriteStream(filename));
+  } else {
+    log(`[Copy 2] '${url2}' to '${filename}'`);
+    requestAction = fs$1.createReadStream(path.join(options.dir || "", url2));
+    requestAction.pipe(fs$1.createWriteStream(filename));
+  }
+  return new Promise((resolve, _reject) => {
+    requestAction.on("error", (err) => {
+      log("[Download Error] Error while downloading: " + url2);
+      log(err);
+      fs$1.unlinkSync(filename);
+      resolve();
+    });
+    requestAction.on("end", () => {
+      log("[Download Success] " + url2);
+      resolve();
+    });
+  });
+};
+const downloadAllImages = async (epubData) => {
+  const { images } = epubData;
+  if (images.length === 0) return;
+  fs$1.ensureDirSync(path.join(epubData.dir, "OEBPS", "images"));
+  for (const image of images) {
+    await downloadImage(epubData, image);
+  }
+};
+const epub2_content_opf_ejs = `<?xml version="1.0" encoding="UTF-8"?>
+<package xmlns="http://www.idpf.org/2007/opf"
+         version="2.0"
+         unique-identifier="BookId">
+
+    <metadata xmlns:dc="http://purl.org/dc/elements/1.1/"
+              xmlns:opf="http://www.idpf.org/2007/opf">
+
+        <dc:identifier id="BookId" opf:scheme="URN"><%= id %></dc:identifier>
+        <dc:title><%= title %></dc:title>
+        <dc:description><%= description %></dc:description>
+        <dc:publisher><%= publisher || "anonymous" %></dc:publisher>
+        <dc:creator opf:role="aut" opf:file-as="<%= author.length ? author.join(",") : author %>"><%= author.length ? author.join(",") : author %></dc:creator>
+        <dc:date opf:event="modification"><%= date %></dc:date>
+        <dc:language><%= lang || "en" %></dc:language>
+        <meta name="cover" content="image_cover"/>
+        <meta name="generator" content="epub-gen"/>
+
+    </metadata>
+
+    <manifest>
+        <item id="ncx" href="toc.ncx" media-type="application/x-dtbncx+xml"/>
+        <item id="toc" href="toc.xhtml" media-type="application/xhtml+xml"/>
+        <item id="css" href="style.css" media-type="text/css"/>
+
+        <% if(locals.cover) { %>
+            <item id="image_cover" href="cover.<%= _coverExtension %>" media-type="<%= _coverMediaType %>"/>
+        <% } %>
+
+        <% images.forEach(function(image, index){ %>
+            <item id="image_<%= index %>" href="images/<%= image.id %>.<%= image.extension %>" media-type="<%= image.mediaType %>"/>
+        <% }) %>
+
+        <% content.forEach(function(content, index){ %>
+            <item id="content_<%= index %>_<%= content.id %>" href="<%= content.href %>" media-type="application/xhtml+xml"/>
+        <% }) %>
+
+        <% fonts.forEach(function(font, index) { %>
+            <item id="font_<%= index %>" href="fonts/<%= font %>" media-type="application/x-font-ttf"/>
+        <% }) %>
+    </manifest>
+
+    <spine toc="ncx">
+        <% content.forEach(function(content, index){ %>
+            <% if(content.beforeToc && !content.excludeFromToc){ %>
+                <itemref idref="content_<%= index %>_<%= content.id %>"/>
+            <% } %>
+        <% }) %>
+        <itemref idref="toc"/>
+        <% content.forEach(function(content, index){ %>
+            <% if(!content.beforeToc && !content.excludeFromToc){ %>
+                <itemref idref="content_<%= index %>_<%= content.id %>"/>
+            <% } %>
+        <% }) %>
+    </spine>
+    <guide/>
+</package>
+`;
+const epub2_toc_xhtml_ejs = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xml:lang="<%- lang %>" xmlns="http://www.w3.org/1999/xhtml">
+<head>
+    <title><%= title %></title>
+    <meta charset="UTF-8"/>
+    <link rel="stylesheet" type="text/css" href="style.css"/>
+</head>
+<body>
+<h1 class="h1"><%= tocTitle %></h1>
+<% content.forEach(function(content, index){ %>
+    <% if(!content.excludeFromToc){ %>
+        <p class="table-of-content">
+            <a href="<%= content.href %>"><%= (1 + index) + ". " + (content.title || "Chapter " + (1 + index)) %>
+                <% if(content.author.length){ %>
+                    - <small class="toc-author"><%= content.author.join(",") %></small>
+                <% } %>
+                <% if(content.url){ %><span class="toc-link"><%= content.url %></span>
+                <% }else{ %><span class="toc-link"></span>
+                <% } %>
+            </a>
+        </p>
+    <% } %>
+<% }) %>
+</body>
+</html>
+`;
+const epub3_content_opf_ejs = `<?xml version="1.0" encoding="UTF-8"?>
+<package xmlns="http://www.idpf.org/2007/opf"
+         version="3.0"
+         unique-identifier="BookId"
+         xmlns:dc="http://purl.org/dc/elements/1.1/"
+         xmlns:dcterms="http://purl.org/dc/terms/"
+         xml:lang="en"
+         xmlns:media="http://www.idpf.org/epub/vocab/overlays/#"
+         prefix="ibooks: http://vocabulary.itunes.apple.com/rdf/ibooks/vocabulary-extensions-1.0/">
+
+    <metadata xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:opf="http://www.idpf.org/2007/opf">
+
+        <dc:identifier id="BookId"><%= id %></dc:identifier>
+        <meta refines="#BookId" property="identifier-type" scheme="onix:codelist5">22</meta>
+        <meta property="dcterms:identifier" id="meta-identifier">BookId</meta>
+        <dc:title><%= title %></dc:title>
+        <meta property="dcterms:title" id="meta-title"><%= title %></meta>
+        <dc:language><%= lang || "en" %></dc:language>
+        <meta property="dcterms:language" id="meta-language"><%= lang || "en" %></meta>
+        <meta property="dcterms:modified"><%= (new Date()).toISOString().split(".")[0] + "Z" %></meta>
+        <dc:creator id="creator"><%= author.length ? author.join(",") : author %></dc:creator>
+        <meta refines="#creator" property="file-as"><%= author.length ? author.join(",") : author %></meta>
+        <meta property="dcterms:publisher"><%= publisher || "anonymous" %></meta>
+        <dc:publisher><%= publisher || "anonymous" %></dc:publisher>
+        <% var date = new Date(); var year = date.getFullYear(); var month = date.getMonth() + 1; var day = date.getDate(); var stringDate = "" + year + "-" + month + "-" + day; %>
+        <meta property="dcterms:date"><%= stringDate %></meta>
+        <dc:date><%= stringDate %></dc:date>
+        <meta property="dcterms:rights">All rights reserved</meta>
+        <dc:rights>Copyright &#x00A9; <%= (new Date()).getFullYear() %> by <%= publisher || "anonymous" %></dc:rights>
+        <% if(locals.cover) { %>
+            <meta name="cover" content="image_cover" />
+        <% } %>
+        <meta name="generator" content="epub-gen" />
+        <meta property="ibooks:specified-fonts">true</meta>
+    </metadata>
+
+    <manifest>
+        <item id="ncx" href="toc.ncx" media-type="application/x-dtbncx+xml" />
+        <item id="toc" href="toc.xhtml" media-type="application/xhtml+xml" properties="nav" />
+        <item id="css" href="style.css" media-type="text/css" />
+
+        <% if(locals.cover) { %>
+            <item id="image_cover" href="cover.<%= _coverExtension %>" media-type="<%= _coverMediaType %>" />
+        <% } %>
+
+        <% images.forEach(function(image, index){ %>
+            <item id="image_<%= index %>" href="images/<%= image.id %>.<%= image.extension %>" media-type="<%= image.mediaType %>" />
+        <% }) %>
+
+        <% function renderContentItem(content) { %>
+            <% content.forEach(function(content){ %>
+                <item id="content_<%= content.id %>" href="<%= content.href %>" media-type="application/xhtml+xml" />
+                <% if (Array.isArray(content.children)) { %>
+                    <% renderContentItem(content.children) %>
+                <% } %>
+            <% }) %>
+        <% } %>
+        <% renderContentItem(content) %>
+
+        <% fonts.forEach(function(font, index){ %>
+            <item id="font_<%= index %>" href="fonts/<%= font %>" media-type="application/x-font-ttf" />
+        <% }) %>
+    </manifest>
+
+    <spine toc="ncx">
+        <% var nodes_1 = content.filter(item => !item.excludeFromToc && item.beforeToc) %>
+        <% var nodes_2 = content.filter(item => !item.excludeFromToc && !item.beforeToc) %>
+        <% function renderToc(nodes) { %>
+            <% nodes.forEach(function(content){ %>
+                <itemref idref="content_<%= content.id %>" />
+                <% if (Array.isArray(content.children)) { %>
+                    <% renderToc(content.children) %>
+                <% } %>
+            <% }) %>
+        <% } %>
+        <% renderToc(nodes_1) %>
+        <itemref idref="toc" />
+        <% renderToc(nodes_2) %>
+    </spine>
+    <guide>
+        <reference type="text" title="Table of Content" href="toc.xhtml" />
+    </guide>
+</package>
+`;
+const epub3_toc_xhtml_ejs = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" xml:lang="<%- lang %>"
+      lang="<%- lang %>">
+<head>
+    <title><%= title %></title>
+    <meta charset="UTF-8" />
+    <link rel="stylesheet" type="text/css" href="style.css" />
+</head>
+<body>
+<h1 class="h1"><%= tocTitle %></h1>
+<nav id="toc" class="TOC" epub:type="toc">
+    <% var nodes_1 = content.filter(item => !item.excludeFromToc && item.beforeToc) %>
+    <% var nodes_2 = content.filter(item => !item.excludeFromToc && !item.beforeToc) %>
+    <% function renderToc(nodes, indent = 0) { %>
+        <ol>
+            <% nodes.forEach(function(content, index){ %>
+                <li class="table-of-content">
+                    <a href="<%= content.href %>"><%= (content.title || "Chapter " + (1 + index)) %>
+                        <% if(content.author.length){ %> - <small
+                                class="toc-author"><%= content.author.join(",") %></small>
+                        <% } %>
+                        <% if(content.url){ %><span class="toc-link"><%= content.url %></span>
+                        <% } %>
+                    </a>
+                    <% if (Array.isArray(content.children) && content.children.length > 0) { %>
+                        <% renderToc(content.children, indent + 1) %>
+                    <% } %>
+                </li>
+            <% }) %>
+        </ol>
+    <% } %>
+    <% renderToc(nodes_1) %>
+    <% renderToc(nodes_2) %>
+</nav>
+
+</body>
+</html>
+`;
+const template_css = `.epub-author {
+  color: #555;
+}
+
+.epub-link {
+  margin-bottom: 30px;
+}
+
+.epub-link a {
+  color: #666;
+  font-size: 90%;
+}
+
+.toc-author {
+  font-size: 90%;
+  color: #555;
+}
+
+.toc-link {
+  color: #999;
+  font-size: 85%;
+  display: block;
+}
+
+hr {
+  border: 0;
+  border-bottom: 1px solid #dedede;
+  margin: 60px 10%;
+}
+
+.TOC > ol {
+  margin: 0;
+  padding: 0;
+}
+
+.TOC > ol ol {
+  padding: 0;
+  margin-left: 2em;
+}
+
+.TOC li {
+  font-size: 16px;
+  list-style: none;
+  margin: 0 auto;
+  padding: 0;
+}
+`;
+const toc_ncx_ejs = `<?xml version="1.0" encoding="UTF-8"?>
+<ncx xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1">
+    <head>
+        <meta name="dtb:uid" content="<%= id %>"/>
+        <meta name="dtb:generator" content="epub-gen"/>
+        <meta name="dtb:depth" content="<%= (toc_depth || 1)%>"/>
+        <meta name="dtb:totalPageCount" content="0"/>
+        <meta name="dtb:maxPageNumber" content="0"/>
+    </head>
+    <docTitle>
+        <text><%= title %></text>
+    </docTitle>
+    <docAuthor>
+        <text><%= author %></text>
+    </docAuthor>
+    <navMap>
+        <% var _index = 1; %>
+        <% var nodes_1 = content.filter(c => !c.excludeFromToc && c.beforeToc) %>
+        <% var nodes_2 = content.filter(c => !c.excludeFromToc && !c.beforeToc) %>
+        <% function renderToc(nodes) { %>
+            <% nodes.forEach(function(content, index){ %>
+                <navPoint id="content_<%= content.id %>" playOrder="<%= _index++ %>" class="chapter">
+                    <navLabel>
+                        <text><%= (tocAutoNumber ? ((1 + index) + ". ") : "") + (content.title || "Chapter " + (1 + index)) %></text>
+                    </navLabel>
+                    <content src="<%= content.href %>"/>
+                    <% if (Array.isArray(content.children)) { %>
+                    <% renderToc(content.children) %>
+                    <% } %>
+                </navPoint>
+            <% }) %>
+        <% } %>
+
+        <% renderToc(nodes_1) %>
+
+        <navPoint id="toc" playOrder="<%= _index++ %>" class="chapter">
+            <navLabel>
+                <text><%= tocTitle %></text>
+            </navLabel>
+            <content src="toc.xhtml"/>
+        </navPoint>
+
+        <% renderToc(nodes_2) %>
+    </navMap>
+</ncx>
+`;
+const generateTempFile = async (epubData) => {
+  const { log } = epubData;
+  const oebps_dir = path.join(epubData.dir, "OEBPS");
+  await fs$1.ensureDir(oebps_dir);
+  epubData.css = epubData.css || template_css;
+  await writeFile(path.join(oebps_dir, "style.css"), epubData.css, "utf-8");
+  if (epubData.fonts?.length) {
+    const fonts_dir = path.join(oebps_dir, "fonts");
+    await fs$1.ensureDir(fonts_dir);
+    epubData.fonts = epubData.fonts.map((font) => {
+      const filename = path.basename(font);
+      if (!fs$1.existsSync(font)) {
+        log(`Custom font not found at '${font}'.`);
+      } else {
+        fs$1.copySync(font, path.join(fonts_dir, filename));
+      }
+      return filename;
+    });
+  }
+  const isAppendTitle = (global_append, local_append) => {
+    if (typeof local_append === "boolean") return local_append;
+    return !!global_append;
+  };
+  const saveContentToFile = (content) => {
+    const title = entities__namespace.encodeXML(content.title || "");
+    let html = `${epubData.docHeader}
+<head>
+<meta charset="UTF-8" />
+<title>${title}</title>
+<link rel="stylesheet" type="text/css" href="style.css" />
+</head>
+<body>
+`;
+    if (content.title && isAppendTitle(epubData.appendChapterTitles, content.appendChapterTitle)) {
+      html += `<h1>${title}</h1>`;
+    }
+    html += content.title && content.author && content.author?.length ? `<p class='epub-author'>${entities__namespace.encodeXML(content.author.join(", "))}</p>` : "";
+    html += content.title && content.url ? `<p class="epub-link"><a href="${content.url}">${content.url}</a></p>` : "";
+    html += `${content.data}`;
+    html += "\n</body>\n</html>";
+    fs$1.ensureDirSync(path.dirname(content.filePath));
+    fs$1.writeFileSync(content.filePath, html, "utf-8");
+    if (Array.isArray(content.children)) {
+      content.children.map(saveContentToFile);
+    }
+  };
+  epubData.content.map(saveContentToFile);
+  const metainf_dir = path.join(epubData.dir, "META-INF");
+  fs$1.ensureDirSync(metainf_dir);
+  fs$1.writeFileSync(
+    path.join(metainf_dir, "container.xml"),
+    `<?xml version="1.0" encoding="UTF-8" ?>
+<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
+<rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles>
+</container>`,
+    "utf-8"
+  );
+  if (epubData.version === 2) {
+    const fn = path.join(metainf_dir, "com.apple.ibooks.display-options.xml");
+    fs$1.writeFileSync(
+      fn,
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<display_options>
+  <platform name="*">
+    <option name="specified-fonts">true</option>
+  </platform>
+</display_options>
+`,
+      "utf-8"
+    );
+  }
+  let opfTemplate;
+  let ncxTocTemplate;
+  let htmlTocTemplate;
+  if (epubData.customOpfTemplatePath && fs$1.existsSync(epubData.customOpfTemplatePath)) {
+    const { readFile } = require("./libs/utils");
+    opfTemplate = await readFile(epubData.customOpfTemplatePath, "utf-8");
+  } else {
+    opfTemplate = epubData.version === 2 ? epub2_content_opf_ejs : epub3_content_opf_ejs;
+  }
+  if (epubData.customNcxTocTemplatePath && fs$1.existsSync(epubData.customNcxTocTemplatePath)) {
+    const { readFile } = require("./libs/utils");
+    ncxTocTemplate = await readFile(epubData.customNcxTocTemplatePath, "utf-8");
+  } else {
+    ncxTocTemplate = toc_ncx_ejs;
+  }
+  if (epubData.customHtmlTocTemplatePath && fs$1.existsSync(epubData.customHtmlTocTemplatePath)) {
+    const { readFile } = require("./libs/utils");
+    htmlTocTemplate = await readFile(epubData.customHtmlTocTemplatePath, "utf-8");
+  } else {
+    htmlTocTemplate = epubData.version === 2 ? epub2_toc_xhtml_ejs : epub3_toc_xhtml_ejs;
+  }
+  const toc_depth = 1;
+  fs$1.writeFileSync(path.join(oebps_dir, "content.opf"), ejs.render(opfTemplate, epubData), "utf-8");
+  fs$1.writeFileSync(
+    path.join(oebps_dir, "toc.ncx"),
+    ejs.render(ncxTocTemplate, { ...epubData, toc_depth }),
+    "utf-8"
+  );
+  fs$1.writeFileSync(
+    path.join(oebps_dir, "toc.xhtml"),
+    simpleMinifier(ejs.render(htmlTocTemplate, epubData)),
+    "utf-8"
+  );
+};
+async function makeCover(data) {
+  const { cover, _coverExtension, log } = data;
+  if (!cover) return;
+  const destPath = path.join(data.dir, "OEBPS", `cover.${_coverExtension}`);
+  let writeStream = null;
+  if (cover.startsWith("http")) {
+    writeStream = request.get(cover).set({ "User-Agent": USER_AGENT });
+    writeStream.pipe(fs$1.createWriteStream(destPath));
+  } else {
+    if (!fs$1.existsSync(cover)) return;
+    log("local cover image: " + cover);
+    writeStream = fs$1.createReadStream(cover);
+    writeStream.pipe(fs$1.createWriteStream(destPath));
+  }
+  return new Promise((resolve) => {
+    writeStream.on("end", () => {
+      log("[Success] cover image saved.");
+      resolve();
+    });
+    writeStream.on("error", (e) => {
+      log("[Error] cover image error: " + e.message);
+      log("destPath: " + destPath);
+      if (fs$1.existsSync(destPath)) {
+        try {
+          fs$1.unlinkSync(destPath);
+          log("destPath removed.");
+        } catch (e2) {
+          log("[Error] remove cover image error: " + e2.message);
+        }
+      }
+      resolve(e);
+    });
+  });
+}
+async function render(data) {
+  const { log } = data;
+  log("Generating Template Files...");
+  await generateTempFile(data);
+  log("Downloading Images...");
+  await downloadAllImages(data);
+  log("Making Cover...");
+  await makeCover(data);
+  log("Generating Epub Files...");
+  await genEpub(data);
+  if (fs$1.existsSync(data.output)) {
+    log("Output: " + data.output);
+    log("Done.");
+  } else {
+    log("Output fail!");
+  }
+}
+async function genEpub(epubData) {
+  const { log, dir, output } = epubData;
+  const archive = archiver("zip", { zlib: { level: 9 } });
+  const outputStream = fs$1.createWriteStream(epubData.output);
+  log("Zipping temp dir to " + output);
+  return new Promise((resolve, reject) => {
+    archive.on("end", async () => {
+      log("Done zipping, clearing temp dir...");
+      const stable = await fileIsStable(epubData.output);
+      if (!stable) {
+        log("Output epub file is not stable!");
+      }
+      try {
+        fs$1.removeSync(dir);
+        resolve();
+      } catch (e) {
+        log("[Error] " + e.message);
+        reject(e);
+      }
+    });
+    archive.on("close", () => {
+      log("Zip close..");
+    });
+    archive.on("finish", () => {
+      log("Zip finish..");
+    });
+    archive.on("error", (err) => {
+      log("[Archive Error] " + err.message);
+      reject(err);
+    });
+    archive.pipe(outputStream);
+    archive.append("application/epub+zip", { store: true, name: "mimetype" });
+    archive.directory(path.join(dir, "META-INF"), "META-INF");
+    archive.directory(path.join(dir, "OEBPS"), "OEBPS");
+    archive.finalize();
+  });
+}
+const mimeModule = require("mime/lite");
+const mime = mimeModule.default || mimeModule;
+const __filename$1 = url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
+const __dirname$1 = path.dirname(__filename$1);
+const baseDir = __dirname$1;
+function result(success, message, options) {
+  if (options && options.verbose) {
+    if (!success) {
+      logger.error(new Error(message));
+    }
+  }
+  const out = {
+    success
+  };
+  if (typeof message === "string") {
+    out.message = message;
+  }
+  if (options) {
+    out.options = options;
+  }
+  return out;
+}
+function check(options) {
+  if (!options.output) {
+    return result(false, errors.no_output_path, options);
+  }
+  if (!options.title) {
+    return result(false, errors.no_title, options);
+  }
+  if (!options.content) {
+    return result(false, errors.no_content, options);
+  }
+  return result(true, void 0, options);
+}
+function parseOptions(options) {
+  const tmpDir = options.tmpDir || os.tmpdir();
+  const id = uuid.v4();
+  const data = {
+    description: options.title,
+    publisher: "anonymous",
+    author: ["anonymous"],
+    tocTitle: "Table Of Contents",
+    appendChapterTitles: true,
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    lang: "en",
+    fonts: [],
+    version: 3,
+    verbose: true,
+    timeoutSeconds: 15 * 60,
+    // 15 min
+    tocAutoNumber: false,
+    ...options,
+    id,
+    tmpDir,
+    dir: path.resolve(tmpDir, id),
+    baseDir,
+    docHeader: "",
+    images: [],
+    content: [],
+    log: (msg) => options.verbose && logger.log(msg)
+  };
+  if (data.version === 2) {
+    data.docHeader = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="#{self.options.lang}">
+`;
+  } else {
+    data.docHeader = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" lang="#{self.options.lang}">
+`;
+  }
+  if (Array.isArray(data.author) && data.author.length === 0) {
+    data.author = ["anonymous"];
+  }
+  if (typeof data.author === "string") {
+    data.author = [data.author];
+  }
+  data.content = options.content.map((content, index) => parseContent(content, index, data));
+  if (data.cover) {
+    data._coverMediaType = mime.getType(data.cover) || "";
+    data._coverExtension = mime.getExtension(data._coverMediaType) || "";
+  }
+  return data;
+}
+async function epubGen(options, configs) {
+  if (configs?.logger) {
+    logger.setLogger(configs.logger);
+  }
+  options = { ...options };
+  const o = check(options);
+  const verbose = options.verbose !== false;
+  if (!o.success) {
+    if (verbose) logger.error(o.message);
+    return o;
+  }
+  let t;
+  try {
+    const data = parseOptions(options);
+    const timeoutSeconds = data.timeoutSeconds || 0;
+    if (timeoutSeconds > 0) {
+      if (verbose) logger.log(`TIMEOUT: ${timeoutSeconds}s`);
+      t = setTimeout(() => {
+        throw new Error("timeout!");
+      }, timeoutSeconds * 1e3);
+    } else {
+      if (verbose) logger.log(`TIMEOUT: N/A`);
+    }
+    await render(data);
+    return result(true, void 0, data);
+  } catch (e) {
+    if (verbose) logger.error(e);
+    return result(false, e.message, options);
+  } finally {
+    clearTimeout(t);
+  }
+}
+const gen = epubGen;
+exports.epubGen = epubGen;
+exports.errors = errors;
+exports.gen = gen;