wp-epub-gen 0.1.4 → 0.2.1

package/build/index.js

@@ -1,128 +1,757 @@
 "use strict";
-/**
- * index.ts
- * @author: oldj
- * @homepage: https://oldj.net
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gen = exports.epubGen = void 0;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const mime = require("mime");
 const os = require("os");
 const path = require("path");
-const uuid_1 = require("uuid");
-const errors_1 = require("./errors");
-const parseContent_1 = require("./parseContent");
-const render_1 = require("./render");
-const baseDir = path.dirname(__dirname);
-function result(success, message, options) {
-    if (options && options.verbose) {
-        if (!success) {
-            console.error(new Error(message));
-        }
+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");
+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]
+        });
+      }
     }
-    let out = {
-        success,
-    };
-    if (typeof message === 'string') {
-        out.message = message;
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const mime__namespace = /* @__PURE__ */ _interopNamespaceDefault(mime);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const fs__namespace$1 = /* @__PURE__ */ _interopNamespaceDefault(fs$1);
+const request__namespace = /* @__PURE__ */ _interopNamespaceDefault(request);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const ejs__namespace = /* @__PURE__ */ _interopNamespaceDefault(ejs);
+const entities__namespace = /* @__PURE__ */ _interopNamespaceDefault(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, "_");
+}
+function parseContent(content, index, epubConfigs) {
+  let 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);
+    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, {
+    lowerCaseTags: true,
+    recognizeSelfClosing: true
+  });
+  let body = $("body");
+  if (body.length) {
+    let html = body.html();
+    if (html) {
+      $ = cheerio.load(html, {
+        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>"));
+      }
     }
-    if (options) {
-        out.options = options;
+  });
+  $("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 = uuid.v4();
+      let mediaType = mime.getType(url.replace(/\?.*/, "")) || "";
+      extension = mime.getExtension(mediaType) || "";
+      let dir = chapter.dir || "";
+      let img = { id, url, dir, mediaType, extension };
+      epubConfigs.images.push(img);
     }
-    return out;
+    $(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;
 }
-function check(options) {
-    if (!options.output) {
-        return result(false, errors_1.errors.no_output_path, options);
+const readFile = util.promisify(fs__namespace.readFile);
+const writeFile = util.promisify(fs__namespace.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 = new Date().getTime();
+  let last_size = fs__namespace.statSync(filename).size;
+  while (new Date().getTime() - start_time <= max_wait) {
+    await wait(1e3);
+    let size = fs__namespace.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__namespace.join(epub_dir, "OEBPS", "images");
+  fs__namespace$1.ensureDirSync(image_dir);
+  let filename = path__namespace.join(image_dir, options.id + "." + options.extension);
+  if (url.startsWith("file://") || url.startsWith("/")) {
+    let auxPath = url.replace(/^file:\/\//i, "");
+    if (process.platform === "win32") {
+      if (auxPath.match(/^\/[a-zA-Z]:/)) {
+        auxPath = auxPath.replace(/^\//, "");
+      }
     }
-    if (!options.title) {
-        return result(false, errors_1.errors.no_title, options);
+    log(`[Copy 1] '${auxPath}' to '${filename}'`);
+    if (fs__namespace$1.existsSync(auxPath)) {
+      try {
+        fs__namespace$1.copySync(auxPath, filename);
+      } catch (e) {
+        log("[Copy 1 Error] " + e.message);
+      }
+    } else {
+      log(`[Copy 1 Fail] '${url}' not exists!`);
     }
-    if (!options.content) {
-        return result(false, errors_1.errors.no_content, options);
+    return;
+  }
+  let requestAction;
+  if (url.startsWith("http")) {
+    requestAction = request__namespace.get(url).set({ "User-Agent": USER_AGENT });
+    requestAction.pipe(fs__namespace$1.createWriteStream(filename));
+  } else {
+    log(`[Copy 2] '${url}' to '${filename}'`);
+    requestAction = fs__namespace$1.createReadStream(path__namespace.join(options.dir || "", url));
+    requestAction.pipe(fs__namespace$1.createWriteStream(filename));
+  }
+  return new Promise((resolve, reject) => {
+    requestAction.on("error", (err) => {
+      log("[Download Error] Error while downloading: " + url);
+      log(err);
+      fs__namespace$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__namespace$1.ensureDirSync(path__namespace.join(epubData.dir, "OEBPS", "images"));
+  for (let image of images) {
+    await downloadImage(epubData, image);
+  }
+};
+const generateTempFile = async (epubData) => {
+  var _a;
+  let { log } = epubData;
+  let oebps_dir = path__namespace.join(epubData.dir, "OEBPS");
+  await fs__namespace$1.ensureDir(oebps_dir);
+  const templates_dir = path__namespace.join(epubData.baseDir, "templates");
+  epubData.css = epubData.css || await readFile(path__namespace.join(templates_dir, "template.css"), "utf-8");
+  await writeFile(path__namespace.join(oebps_dir, "style.css"), epubData.css, "utf-8");
+  if ((_a = epubData.fonts) == null ? void 0 : _a.length) {
+    let fonts_dir = path__namespace.join(oebps_dir, "fonts");
+    await fs__namespace$1.ensureDir(fonts_dir);
+    epubData.fonts = epubData.fonts.map((font) => {
+      let filename = path__namespace.basename(font);
+      if (!fs__namespace$1.existsSync(font)) {
+        log(`Custom font not found at '${font}'.`);
+      } else {
+        fs__namespace$1.copySync(font, path__namespace.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) => {
+    var _a2;
+    let 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 && ((_a2 = content.author) == null ? void 0 : _a2.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__namespace$1.ensureDirSync(path__namespace.dirname(content.filePath));
+    fs__namespace$1.writeFileSync(content.filePath, html, "utf-8");
+    if (Array.isArray(content.children)) {
+      content.children.map(saveContentToFile);
+    }
+  };
+  epubData.content.map(saveContentToFile);
+  let metainf_dir = path__namespace.join(epubData.dir, "META-INF");
+  fs__namespace$1.ensureDirSync(metainf_dir);
+  fs__namespace$1.writeFileSync(
+    path__namespace.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__namespace.join(metainf_dir, "com.apple.ibooks.display-options.xml");
+    fs__namespace$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 opfPath = epubData.customOpfTemplatePath || path__namespace.join(templates_dir, `epub${epubData.version}`, "content.opf.ejs");
+  if (!fs__namespace$1.existsSync(opfPath)) {
+    throw new Error("Custom file to OPF template not found.");
+  }
+  let ncxTocPath = epubData.customNcxTocTemplatePath || path__namespace.join(templates_dir, `toc.ncx.ejs`);
+  if (!fs__namespace$1.existsSync(ncxTocPath)) {
+    throw new Error("Custom file the NCX toc template not found.");
+  }
+  let htmlTocPath = epubData.customHtmlTocTemplatePath || path__namespace.join(templates_dir, `epub${epubData.version}`, "toc.xhtml.ejs");
+  if (!fs__namespace$1.existsSync(htmlTocPath)) {
+    throw new Error("Custom file to HTML toc template not found.");
+  }
+  let toc_depth = 1;
+  fs__namespace$1.writeFileSync(
+    path__namespace.join(oebps_dir, "content.opf"),
+    await ejs__namespace.renderFile(opfPath, epubData),
+    "utf-8"
+  );
+  fs__namespace$1.writeFileSync(
+    path__namespace.join(oebps_dir, "toc.ncx"),
+    await ejs__namespace.renderFile(ncxTocPath, { ...epubData, toc_depth }),
+    "utf-8"
+  );
+  fs__namespace$1.writeFileSync(
+    path__namespace.join(oebps_dir, "toc.xhtml"),
+    simpleMinifier(await ejs__namespace.renderFile(htmlTocPath, epubData)),
+    "utf-8"
+  );
+};
+async function makeCover(data) {
+  let { cover, _coverExtension, log } = data;
+  if (!cover)
+    return;
+  let destPath = path__namespace.join(data.dir, "OEBPS", `cover.${_coverExtension}`);
+  let writeStream = null;
+  if (cover.startsWith("http")) {
+    writeStream = request__namespace.get(cover).set({ "User-Agent": USER_AGENT });
+    writeStream.pipe(fs__namespace$1.createWriteStream(destPath));
+  } else {
+    if (!fs__namespace$1.existsSync(cover))
+      return;
+    log("local cover image: " + cover);
+    writeStream = fs__namespace$1.createReadStream(cover);
+    writeStream.pipe(fs__namespace$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__namespace$1.existsSync(destPath)) {
+        try {
+          fs__namespace$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 baseDir = path__namespace.dirname(__dirname);
+function result(success, message, options) {
+  if (options && options.verbose) {
+    if (!success) {
+      console.error(new Error(message));
     }
-    return result(true, undefined, options);
+  }
+  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 = (0, uuid_1.v4)();
-    let data = Object.assign(Object.assign({ description: options.title, publisher: 'anonymous', author: ['anonymous'], tocTitle: 'Table Of Contents', appendChapterTitles: true, date: new Date().toISOString(), lang: 'en', fonts: [], version: 3, verbose: true, timeoutSeconds: 15 * 60, 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"?>
+  let tmpDir = options.tmpDir || os__namespace.tmpdir();
+  let id = uuid.v4();
+  let data = {
+    description: options.title,
+    publisher: "anonymous",
+    author: ["anonymous"],
+    tocTitle: "Table Of Contents",
+    appendChapterTitles: true,
+    date: new Date().toISOString(),
+    lang: "en",
+    fonts: [],
+    version: 3,
+    verbose: true,
+    timeoutSeconds: 15 * 60,
+    tocAutoNumber: false,
+    ...options,
+    id,
+    tmpDir,
+    dir: path__namespace.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"?>
+  } 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) => (0, parseContent_1.default)(content, index, data));
-    if (data.cover) {
-        data._coverMediaType = mime.getType(data.cover) || '';
-        data._coverExtension = mime.getExtension(data._coverMediaType) || '';
-    }
-    return data;
+  }
+  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__namespace.getType(data.cover) || "";
+    data._coverExtension = mime__namespace.getExtension(data._coverMediaType) || "";
+  }
+  return data;
 }
-function epubGen(options, output) {
-    return __awaiter(this, void 0, void 0, function* () {
-        options = Object.assign({}, 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 * 1000);
-            }
-            else {
-                if (verbose)
-                    console.log(`TIMEOUT: N/A`);
-            }
-            yield (0, render_1.render)(data);
-            return result(true, undefined, data);
-        }
-        catch (e) {
-            if (verbose)
-                console.error(e);
-            return result(false, e.message, options);
-        }
-        finally {
-            clearTimeout(t);
-        }
-    });
+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;
 exports.epubGen = epubGen;
-exports.gen = epubGen;
-//# sourceMappingURL=index.js.map
+exports.errors = errors;
+exports.gen = gen;