wp-epub-gen 0.2.3 → 0.3.0

package/build/index.mjs

@@ -0,0 +1,1043 @@
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import { v4 } from "uuid";
+import * as cheerio from "cheerio";
+import { remove } from "diacritics";
+import uslug from "uslug";
+import archiver from "archiver";
+import fs$1 from "fs-extra";
+import request from "superagent";
+import fs from "fs";
+import { promisify } from "util";
+import ejs from "ejs";
+import * as entities from "entities";
+const errors = {
+  no_output_path: "No output path!",
+  no_title: "Title is required.",
+  no_content: "Content is required."
+};
+function safeFineName(name) {
+  return name.replace(/[/\\?%*:|"<>\t\r\n]/g, "_");
+}
+const mimeModule$1 = require("mime/lite");
+const mime$1 = mimeModule$1.default || mimeModule$1;
+function parseContent(content, index, epubConfigs) {
+  let chapter = { ...content };
+  let { filename } = chapter;
+  if (!filename) {
+    let titleSlug = uslug(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);
+    let 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;
+  if (chapter.author && typeof chapter.author === "string") {
+    chapter.author = [chapter.author];
+  } else if (!chapter.author || !Array.isArray(chapter.author)) {
+    chapter.author = [];
+  }
+  let allowedAttributes = [
+    "content",
+    "alt",
+    "id",
+    "title",
+    "src",
+    "href",
+    "about",
+    "accesskey",
+    "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",
+    "content",
+    "contenteditable",
+    "contextmenu",
+    "datatype",
+    "dir",
+    "draggable",
+    "dropzone",
+    "hidden",
+    "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",
+    "spellcheck",
+    "style",
+    "tabindex",
+    "target",
+    "title",
+    "type",
+    "typeof",
+    "vocab",
+    "xml:base",
+    "xml:lang",
+    "xml:space",
+    "colspan",
+    "rowspan",
+    "epub:type",
+    "epub:prefix"
+  ];
+  let allowedXhtml11Tags = [
+    "div",
+    "p",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "ul",
+    "ol",
+    "li",
+    "dl",
+    "dt",
+    "dd",
+    "address",
+    "hr",
+    "pre",
+    "blockquote",
+    "center",
+    "ins",
+    "del",
+    "a",
+    "span",
+    "bdo",
+    "br",
+    "em",
+    "strong",
+    "dfn",
+    "code",
+    "samp",
+    "kbd",
+    "bar",
+    "cite",
+    "abbr",
+    "acronym",
+    "q",
+    "sub",
+    "sup",
+    "tt",
+    "i",
+    "b",
+    "big",
+    "small",
+    "u",
+    "s",
+    "strike",
+    "basefont",
+    "font",
+    "object",
+    "param",
+    "img",
+    "table",
+    "caption",
+    "colgroup",
+    "col",
+    "thead",
+    "tfoot",
+    "tbody",
+    "tr",
+    "th",
+    "td",
+    "embed",
+    "applet",
+    "iframe",
+    "img",
+    "map",
+    "noscript",
+    "ns:svg",
+    "object",
+    "script",
+    "table",
+    "tt",
+    "var"
+  ];
+  let $ = cheerio.load(chapter.data, {
+    xml: {
+      lowerCaseTags: true,
+      recognizeSelfClosing: true
+    }
+  });
+  let body = $("body");
+  if (body.length) {
+    let html = body.html();
+    if (html) {
+      $ = cheerio.load(html, {
+        xml: {
+          lowerCaseTags: true,
+          recognizeSelfClosing: true
+        }
+      });
+    }
+  }
+  $($("*").get().reverse()).each(function(elemIndex, elem) {
+    let attrs = elem.attribs;
+    let that = this;
+    let tags = ["img", "br", "hr"];
+    if (tags.includes(that.name)) {
+      if (that.name === "img" && !$(that).attr("alt")) {
+        $(that).attr("alt", "image-placeholder");
+      }
+    }
+    Object.entries(attrs).map(([k, v]) => {
+      if (allowedAttributes.includes(k)) {
+        if (k === "type" && that.name !== "script") {
+          $(that).removeAttr(k);
+        }
+      } else {
+        $(that).removeAttr(k);
+      }
+    });
+    if (epubConfigs.version === 2) {
+      if (!allowedXhtml11Tags.includes(that.name)) {
+        if (epubConfigs.verbose) {
+          console.log(
+            "Warning (content[" + index + "]):",
+            that.name,
+            "tag isn't allowed on EPUB 2/XHTML 1.1 DTD."
+          );
+        }
+        let child = $(that).html();
+        $(that).replaceWith($("<div>" + child + "</div>"));
+      }
+    }
+  });
+  $("img").each((index2, elem) => {
+    let url = $(elem).attr("src") || "";
+    let image = epubConfigs.images.find((el) => el.url === url);
+    let id;
+    let extension;
+    if (image) {
+      id = image.id;
+      extension = image.extension;
+    } else {
+      id = v4();
+      let mediaType = mime$1.getType(url.replace(/\?.*/, "")) || "";
+      extension = mime$1.getExtension(mediaType) || "";
+      let dir = chapter.dir || "";
+      let img = { id, url, dir, mediaType, extension };
+      epubConfigs.images.push(img);
+    }
+    $(elem).attr("src", `images/${id}.${extension}`);
+  });
+  chapter.data = $.xml();
+  if (Array.isArray(chapter.children)) {
+    chapter.children = chapter.children.map(
+      (content2, idx) => parseContent(content2, `${index}_${idx}`, epubConfigs)
+    );
+  }
+  return chapter;
+}
+promisify(fs.readFile);
+const writeFile = 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) {
+  let 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);
+    let 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) => {
+  let { url } = options;
+  let { log } = epubData;
+  let epub_dir = epubData.dir;
+  if (!url) {
+    return;
+  }
+  let image_dir = path.join(epub_dir, "OEBPS", "images");
+  fs$1.ensureDirSync(image_dir);
+  let filename = path.join(image_dir, options.id + "." + options.extension);
+  if (url.startsWith("file://") || url.startsWith("/")) {
+    let aux_path = url.replace(/^file:\/\//i, "");
+    try {
+      aux_path = decodeURIComponent(aux_path);
+    } catch (e) {
+      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] '${url}' not exists!`);
+    }
+    return;
+  }
+  let requestAction;
+  if (url.startsWith("http")) {
+    requestAction = request.get(url).set({ "User-Agent": USER_AGENT });
+    requestAction.pipe(fs$1.createWriteStream(filename));
+  } else {
+    log(`[Copy 2] '${url}' to '${filename}'`);
+    requestAction = fs$1.createReadStream(path.join(options.dir || "", url));
+    requestAction.pipe(fs$1.createWriteStream(filename));
+  }
+  return new Promise((resolve, reject) => {
+    requestAction.on("error", (err) => {
+      log("[Download Error] Error while downloading: " + url);
+      log(err);
+      fs$1.unlinkSync(filename);
+      resolve();
+    });
+    requestAction.on("end", () => {
+      log("[Download Success] " + url);
+      resolve();
+    });
+  });
+};
+const downloadAllImages = async (epubData) => {
+  let { images } = epubData;
+  if (images.length === 0) return;
+  fs$1.ensureDirSync(path.join(epubData.dir, "OEBPS", "images"));
+  for (let 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>
+<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) => {
+  let { log } = epubData;
+  let 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) {
+    let fonts_dir = path.join(oebps_dir, "fonts");
+    await fs$1.ensureDir(fonts_dir);
+    epubData.fonts = epubData.fonts.map((font) => {
+      let 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) => {
+    let title = entities.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.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);
+  let 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) {
+    let 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;
+  }
+  let 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) {
+  let { cover, _coverExtension, log } = data;
+  if (!cover) return;
+  let 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) {
+  let { 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) {
+  let { log, dir, output } = epubData;
+  let archive = archiver("zip", { zlib: { level: 9 } });
+  let 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...");
+      let 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 = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const baseDir = __dirname;
+function result(success, message, options) {
+  if (options && options.verbose) {
+    if (!success) {
+      console.error(new Error(message));
+    }
+  }
+  let 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) {
+  let tmpDir = options.tmpDir || os.tmpdir();
+  let id = v4();
+  let 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 && console.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>
+<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, output) {
+  options = { ...options };
+  if (output) {
+    options.output = output;
+  }
+  let o = check(options);
+  let verbose = options.verbose !== false;
+  if (!o.success) {
+    if (verbose) console.error(o.message);
+    return o;
+  }
+  let t;
+  try {
+    let data = parseOptions(options);
+    let timeoutSeconds = data.timeoutSeconds || 0;
+    if (timeoutSeconds > 0) {
+      if (verbose) console.log(`TIMEOUT: ${timeoutSeconds}s`);
+      t = setTimeout(() => {
+        throw new Error("timeout!");
+      }, timeoutSeconds * 1e3);
+    } else {
+      if (verbose) console.log(`TIMEOUT: N/A`);
+    }
+    await render(data);
+    return result(true, void 0, data);
+  } catch (e) {
+    if (verbose) console.error(e);
+    return result(false, e.message, options);
+  } finally {
+    clearTimeout(t);
+  }
+}
+const gen = epubGen;
+export {
+  epubGen,
+  errors,
+  gen
+};