epub2md 1.1.4 → 1.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 ChandlerVer5
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,13 +1,27 @@
-# 📖 epub2MD
+# 📖 epub2md
 
-The main goal is to convert EPUB to Markdown, but it can also serve as an EPUB parser.
-主要的目标是转换 epub 到 markdown，当然了也可以当做 epub 的解析器 
+Even though the package is primarily intended for CLI is to convert EPUB to Markdown, but it can be used programmatically.
 
-# Global Install for CLI
+主要的目标是转换 epub 到 markdown，当然了也可以当做 epub 的解析器库使用.
 
-```bash
-# cli
-npm install epub2md -g
+## Global Install for CLI
+
+```sh
+# node global cli
+$ npm install epub2md -g
+```
+
+## Development Install
+
+```sh
+# for node
+$ npm install epub2md
+
+# for deno
+$ deno add @xw/epub2md
+
+# from GitHub Packages Registry
+$ npm install @uxiew/epub2md
 ```
 
 ## CLI
@@ -31,20 +45,7 @@ $ epub2md -S ../../fixtures/zhihu.epub
 $ epub2md -s ../../fixtures/zhihu.epub
 ```
 
-# Development Install
-
-```bash
-# npm
-npm install epub2md --save
-
-# pnpm
-pnpm add epub2md
-
-# yarn
-yarn add epub2md
-```
-
-# Usage
+## Usage
 
 ```js
 import { parseEpub } from 'epub2md'
@@ -54,15 +55,15 @@ const epubObj = await parseEpub('/path/to/file.epub')
 console.log('epub content:', epubObj)
 ```
 
-## parseEpub(target: string | buffer, options ?: ParserOptions): EpubObject
+### parseEpub(target: string | buffer, options ?: ParserOptions): EpubObject
 
-### target
+#### target
 
 type: `string` or`buffer`
 
 It can be the path to the file or file's binary string or buffer
 
-### options: `ParserOptions`
+#### options: `ParserOptions`
 
 - type ?: 'binaryString' | 'path' | 'buffer'
 
@@ -73,7 +74,7 @@ It forces the parser to treat supplied target as the defined type, if not define
 
   use custom convert function, you can use turndown or node-html-markdown.etc.
 
-### EpubObject
+#### EpubObject
 
 The return value is an object which contains`structure`, `sections`, `info`(private property names start with `_`.I don't recommend using them, since they are subscribed to change).
 
@@ -85,11 +86,11 @@ The return value is an object which contains`structure`, `sections`, `info`(priv
 
 - `Section.prototype.toHtmlObjects`: convert to html object. And a note about `src` and`href`, the`src` and`href` in raw html stay untouched, but the `toHtmlObjects` method resolves `src` to base64 string, and alters `href` so that they make sense in the parsed epub.And the parsed `href` is something like`#{sectionId},{hash}`.
 
-# How to contribute
+## How to contribute
 
 - Raise an issue in the issue section.
 - PRs are the best. ❤️
 
-# Credits
+## Credits
 
 [gaoxiaoliangz/epub-parser](https://github.com/gaoxiaoliangz/epub-parser)

package/lib/bin/cli.cjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Commands = void 0;
+var _args = _interopRequireDefault(require("args"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _nodeProcess = _interopRequireDefault(require("node:process"));
+var _parseEpub = _interopRequireDefault(require("../parseEpub.cjs"));
+var _convert = _interopRequireDefault(require("./convert.cjs"));
+var _beautyJson = require("beauty-json");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const name = "epub2md";
+var Commands = exports.Commands = /* @__PURE__ */(Commands2 => {
+  Commands2["markdown"] = "md";
+  Commands2["autocorrect"] = "ma";
+  Commands2["unzip"] = "unzip";
+  Commands2["info"] = "info";
+  Commands2["structure"] = "structure";
+  Commands2["sections"] = "sections";
+  return Commands2;
+})(Commands || {});
+const commands = [["md" /* markdown */, "convert the epub file to markdown format"], ["ma" /* autocorrect */, "convert the epub file to markdown format with autocorrect"], ["unzip" /* unzip */, "unzip epub file"], ["info" /* info */, "get epub file basic info"], ["structure" /* structure */, "get epub file structure"], ["sections" /* sections */, "get epub file sections"]];
+const DEFAULT_COMMAND = "md" /* markdown */;
+commands.forEach(cmd => _args.default.option(cmd[0], cmd[1]));
+const flags = _args.default.parse(_nodeProcess.default.argv, {
+  name
+});
+commands.some(([cmd], i) => {
+  if (flags[cmd]) {
+    run(cmd);
+    return true;
+  } else {
+    if (i === commands.length - 1) {
+      if (_nodeProcess.default.argv[2]) {
+        flags[DEFAULT_COMMAND] = _nodeProcess.default.argv[2];
+        run(DEFAULT_COMMAND);
+        return true;
+      }
+      _args.default.showHelp();
+    }
+  }
+});
+function run(cmd) {
+  const epubPath = flags["md" /* markdown */] || flags["ma" /* autocorrect */] || flags["unzip" /* unzip */];
+  if (epubPath) {
+    console.log(_chalk.default.blueBright(`[${name}]: converting${cmd === "ma" /* autocorrect */ ? " with AutoCorrect" : ""}...`));
+    new _convert.default({
+      eubPath: epubPath,
+      cmd
+    }).run(flags["unzip" /* unzip */]).then(outDir => {
+      console.log(_chalk.default.greenBright(`[${name}]: success! output: ${outDir}`));
+    });
+    return;
+  }
+  (0, _parseEpub.default)(flags[cmd]).then(res => {
+    console.log(_chalk.default.greenBright(`[${name}]: This book ${cmd}:`));
+    _beautyJson.json.log(res[cmd]);
+  }).catch(error => {
+    console.log(_chalk.default.red(error));
+  });
+}

package/lib/bin/convert.cjs

@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _nodePath = require("node:path");
+var _nodeFs = require("node:fs");
+var _writeFileSafe = require("write-file-safe");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _parseEpub = _interopRequireDefault(require("../parseEpub.cjs"));
+var _helper = require("./helper.cjs");
+var _utils = require("../utils.cjs");
+var _parseLink = _interopRequireDefault(require("../parseLink.cjs"));
+var _cli = require("./cli.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Converter {
+  epub;
+  // epub parser result
+  epubFilePath;
+  // current epub 's path
+  cmd;
+  // current using command flag
+  MD_FILE_EXT = ".md";
+  // out file extname
+  outDir;
+  // epub 's original directory to save markdown files
+  structure = [];
+  // epub dir structure
+  constructor({
+    eubPath,
+    cmd
+  }) {
+    this.epubFilePath = eubPath;
+    this.cmd = cmd;
+    this.outDir = (0, _nodePath.dirname)(eubPath);
+    if (!(0, _nodeFs.existsSync)(this.outDir)) (0, _nodeFs.mkdirSync)(this.outDir);
+  }
+  checkFileType(filepath) {
+    let isImage,
+      isCSS,
+      isHTML = false;
+    const ext = (0, _nodePath.extname)(filepath);
+    if (",.jpg,.jpeg,.png,.gif,.webp,.svg".includes(ext)) isImage = true;
+    if (",.css".includes(ext)) isCSS = true;
+    if (".htm,.html,.xhtml".includes(ext)) isHTML = true;
+    return {
+      isImage,
+      isCSS,
+      isHTML
+    };
+  }
+  resolveHTMLId(fileName) {
+    return fileName.replace(/\.x?html?(?:.*)/, "");
+  }
+  // 文件名处理
+  getCleanFileName(fileName, ext = "") {
+    return (0, _utils.sanitizeFileName)(fileName).trim().replace(/\s/g, "_") + ext;
+  }
+  /**
+  * Make a path，and normalize assets's path. normally markdowns dont need those css/js files, So i skip them
+  * @return these target file's path will be created，like "xxx/xxx.md","xxx/images"
+  */
+  _makePath(filepath) {
+    const {
+      isImage,
+      isHTML
+    } = this.checkFileType(filepath);
+    if (!isImage && !isHTML) return "";
+    const fileName = (0, _nodePath.basename)(filepath);
+    return (0, _nodePath.join)(this.outDir, isImage ? "images" : "", isHTML ? this.resolveHTMLId(fileName) + this.MD_FILE_EXT : fileName);
+  }
+  async getManifest(unzip) {
+    this.epub = await (0, _parseEpub.default)(this.epubFilePath, {
+      convertToMarkdown: _helper.convertHTML
+    });
+    this.outDir = this.epubFilePath.replace(".epub", "");
+    this.epub.getManifest().forEach(({
+      href: filepath,
+      id
+    }) => {
+      let outpath;
+      if (unzip) outpath = (0, _nodePath.join)(this.outDir, filepath);else {
+        if (filepath.endsWith("ncx") || id === "titlepage") return;
+        outpath = this._makePath(filepath);
+      }
+      if (outpath !== "") this.structure.push({
+        id,
+        outpath,
+        filepath
+      });
+    });
+  }
+  /**
+  * Try to obtain a friendly output filename.
+  */
+  _getFileData(structure) {
+    let {
+      id,
+      filepath,
+      outpath
+    } = structure;
+    let content = "";
+    const needAutoCorrect = this.cmd === _cli.Commands.autocorrect;
+    if ((0, _nodePath.extname)(outpath) === ".md") {
+      let _matchNav = function (tocItems, id2) {
+        if (Array.isArray(tocItems)) for (let i = 0; i < tocItems.length; i++) {
+          const item = tocItems[i];
+          if (item.sectionId === id2) {
+            return item;
+          }
+          if (item.children) {
+            const childMatch = _matchNav(item.children, id2);
+            if (childMatch) {
+              return childMatch;
+            }
+          }
+        }
+        return void 0;
+      };
+      content = this.epub?.getSection(id)?.toMarkdown();
+      const nav = _matchNav(this.epub?.structure, id);
+      const cleanFilename = this.getCleanFileName(nav ? nav.name + this.MD_FILE_EXT : (0, _nodePath.basename)(outpath));
+      outpath = (0, _nodePath.join)((0, _nodePath.dirname)(outpath), cleanFilename);
+      content = (0, _helper.fixLinkPath)(content, (link, text) => {
+        if (text) {
+          const {
+            hash,
+            url
+          } = (0, _parseLink.default)(link);
+          if (link.startsWith("#")) {
+            return "./" + cleanFilename + link;
+          }
+          link = this.resolveHTMLId((0, _nodePath.basename)(url));
+          const anav = (0, _utils.findRealPath)(link, this.epub?.structure) || {
+            name: link
+          };
+          return "./" + this.getCleanFileName((0, _nodePath.extname)(anav.name) ? anav.name : anav.name + this.MD_FILE_EXT) + `${hash ? "#" + hash : ""}`;
+        } else {
+          return "./images/" + (0, _nodePath.basename)(link);
+        }
+      });
+      content = needAutoCorrect ? require("autocorrect-node").format(content) : content;
+    } else {
+      content = this.epub.resolve(filepath).asNodeBuffer();
+    }
+    return {
+      content,
+      outFilePath: outpath
+    };
+  }
+  async run(unzip) {
+    await this.getManifest(unzip);
+    let num = 1,
+      filterPool = {};
+    const padding = Math.floor(Math.log10(this.structure.length));
+    this.structure.forEach(s => {
+      const {
+        outFilePath,
+        content
+      } = this._getFileData(s);
+      let numberedOutFilePath = null;
+      if (content.toString() === "") return;
+      if (!filterPool[outFilePath] && (0, _nodePath.basename)(outFilePath).endsWith(".md")) {
+        const parsedPath = (0, _nodePath.parse)(outFilePath);
+        numberedOutFilePath = (0, _nodePath.format)({
+          ...parsedPath,
+          base: `${("0".repeat(padding) + num).slice(-(padding + 1))}-${parsedPath.base}`
+        });
+        console.log(_chalk.default.yellow(`${num++}: [${(0, _nodePath.basename)(numberedOutFilePath)}]`));
+      }
+      filterPool[outFilePath] = true;
+      (0, _writeFileSafe.writeFileSync)(numberedOutFilePath ?? outFilePath, content, {
+        overwrite: true
+      });
+    });
+    return this.outDir;
+  }
+}
+module.exports = Converter;

package/lib/bin/helper.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertHTML = convertHTML;
+exports.fixLinkPath = fixLinkPath;
+var _converter = _interopRequireDefault(require("../converter.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function handleImagePath(markdownContent, replaceFn) {
+  const imgPattern = /!\[[^\]]*\]\(([^)]+)\)/g;
+  return markdownContent.replace(imgPattern, (match, imagePath) => {
+    const newImagePath = replaceFn(imagePath);
+    return `![${match.slice(2, match.indexOf("]"))}](${newImagePath})`;
+  });
+}
+function handleFileLinkPath(markdownContent, replaceFn) {
+  const inlineLinkPattern = /\[([^\]]*)]\(([^)]+)\)/g;
+  return markdownContent.replace(inlineLinkPattern, (match, linkText, linkUrl) => {
+    let newLinkUrl = linkUrl;
+    newLinkUrl = replaceFn(linkUrl, linkText);
+    return `[${linkText}](${newLinkUrl})`;
+  });
+}
+function fixLinkPath(markdownContent, replaceFn) {
+  const linkPattern = /(!?)\[(.*?)\](\(.*?\)\])?\((.*?)\)/g;
+  return markdownContent.replace(linkPattern, (match, imgMark, internalMatch1, internalMatch2, linkUrl) => {
+    const hasWrappedImg = internalMatch1.startsWith("![");
+    if (imgMark === "!") {
+      return handleImagePath(match, replaceFn);
+    } else if (hasWrappedImg) {
+      let wrappedImg = internalMatch1 + "]" + internalMatch2.replace(/\)\]$/, ")");
+      let m1 = "",
+        m2 = "";
+      const link = handleImagePath(wrappedImg, replaceFn).replace(/(!\[)(.*?)(\]\()/g, (m, mark1, mark, mark2) => {
+        m1 = mark1;
+        m2 = mark2;
+        return "$$" + mark + "@@";
+      });
+      return handleFileLinkPath(link, replaceFn).replace("$$", m1).replace("@@", m2);
+    } else {
+      return handleFileLinkPath(match, replaceFn);
+    }
+  });
+}
+function convertHTML(prunedHtml) {
+  const htmlString = prunedHtml.replace(/（）/g, "()").replace(/：：/g, "::").replace(/\s?<\?xml.*?>\s?/g, "").replace(/\s?<!DOC.*?>\s?/g, "").replace(/\n+\s?/g, "\n");
+  return (0, _converter.default)(htmlString);
+}

package/lib/converter.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _nodeHtmlMarkdown = require("node-html-markdown");
+const convert = str => _nodeHtmlMarkdown.NodeHtmlMarkdown.translate(str, {
+  useLinkReferenceDefinitions: false
+});
+module.exports = convert;

package/lib/converter.d.ts

@@ -1 +1,2 @@
-export declare const convert: (str: string) => string;
+declare const _default: (str: string) => string;
+export default _default;

package/lib/converter.mjs

@@ -0,0 +1,5 @@
+import { NodeHtmlMarkdown } from "node-html-markdown";
+const convert = (str) => NodeHtmlMarkdown.translate(str, {
+  useLinkReferenceDefinitions: false
+});
+export default convert;

package/lib/index.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "convertToMarkdown", {
+  enumerable: true,
+  get: function () {
+    return _converter.default;
+  }
+});
+Object.defineProperty(exports, "parseEpub", {
+  enumerable: true,
+  get: function () {
+    return _parseEpub.default;
+  }
+});
+Object.defineProperty(exports, "parseHTML", {
+  enumerable: true,
+  get: function () {
+    return _parseHTML.default;
+  }
+});
+Object.defineProperty(exports, "parseLink", {
+  enumerable: true,
+  get: function () {
+    return _parseLink.default;
+  }
+});
+var _converter = _interopRequireDefault(require("./converter.cjs"));
+var _parseEpub = _interopRequireDefault(require("./parseEpub.cjs"));
+var _parseLink = _interopRequireDefault(require("./parseLink.cjs"));
+var _parseHTML = _interopRequireDefault(require("./parseHTML.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { convert } from './converter';
+import convert from './converter';
 import parseEpub from './parseEpub';
 import parseLink from './parseLink';
 import parseHTML from './parseHTML';

package/lib/index.mjs

@@ -0,0 +1,5 @@
+import convert from "./converter.mjs";
+import parseEpub from "./parseEpub.mjs";
+import parseLink from "./parseLink.mjs";
+import parseHTML from "./parseHTML.mjs";
+export { convert as convertToMarkdown, parseLink, parseHTML, parseEpub };

package/lib/mobi.cjs

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _pypacker = _interopRequireDefault(require("pypacker"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Mobi {
+  filename;
+  info = {
+    content: "",
+    pdbHeader: {
+      records: []
+    },
+    mobiHeader: {}
+  };
+  constructor(filename) {
+    this.filename = filename;
+    this.parse();
+  }
+  parse() {
+    var bufIndex, buffer, data, fd, file_info, filename, flags, header, id, index, mobiHeader, multibyte, pdbHeader, position, startPosition, trailers, _i, _j, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7;
+    filename = this.filename;
+    file_info = _nodeFs.default.statSync(filename);
+    buffer = new Buffer(file_info.size);
+    fd = _nodeFs.default.openSync(filename, "r");
+    _nodeFs.default.readSync(fd, buffer, 0, file_info.size, 0);
+    pdbHeader = this.info.pdbHeader;
+    _ref = new _pypacker.default("31sxHH6I4s4s2IH").unpack_from(buffer);
+    this.info.name = _ref[0];
+    pdbHeader.attributes = _ref[1];
+    pdbHeader.version = _ref[2];
+    pdbHeader.created = _ref[3];
+    pdbHeader.modified = _ref[4];
+    pdbHeader.backedUp = _ref[5];
+    pdbHeader.modificationNumber = _ref[6];
+    pdbHeader.appInfoId = _ref[7];
+    pdbHeader.sortInfoID = _ref[8];
+    pdbHeader.type = _ref[9];
+    pdbHeader.creator = _ref[10];
+    pdbHeader.uniqueIDseed = _ref[11];
+    pdbHeader.nextRecordListID = _ref[12];
+    pdbHeader.recordCount = _ref[13];
+    this.info.name = this.info.name.replace(/\u0000/g, "");
+    pdbHeader.created = new Date(pdbHeader.created * 1e3);
+    pdbHeader.modified = new Date(pdbHeader.modified * 1e3);
+    pdbHeader.backedUp = new Date(pdbHeader.backedUp * 100);
+    bufIndex = 78;
+    for (index = _i = 0, _ref1 = pdbHeader.recordCount; 0 <= _ref1 ? _i < _ref1 : _i > _ref1; index = 0 <= _ref1 ? ++_i : --_i) {
+      startPosition = bufIndex + index * 8;
+      _ref2 = new _pypacker.default("II").unpack_from(buffer, startPosition), position = _ref2[0], id = _ref2[1];
+      id = id & 16777215;
+      pdbHeader.records.push({
+        position,
+        id
+      });
+    }
+    header = buffer.slice(pdbHeader.records[0].position, pdbHeader.records[1].position);
+    mobiHeader = this.info.mobiHeader;
+    _ref3 = new _pypacker.default("H2xI3H6x3I").unpack_from(header);
+    mobiHeader.compression = _ref3[0];
+    mobiHeader.text_length = _ref3[1];
+    mobiHeader.textRecordCount = _ref3[2];
+    mobiHeader.recordSize = _ref3[3];
+    mobiHeader.encryption = _ref3[4];
+    mobiHeader.headerLength = _ref3[5];
+    mobiHeader.mobiType = _ref3[6];
+    mobiHeader.encoding = _ref3[7];
+    _ref4 = new _pypacker.default("3I").unpack_from(header, 80);
+    mobiHeader.firstNonBookIndex = _ref4[0];
+    mobiHeader.fullNameOffset = _ref4[1];
+    mobiHeader.fullNameLength = _ref4[2];
+    mobiHeader.firstImageIndex = new _pypacker.default("I").unpack_from(header, 108)[0];
+    mobiHeader.exthFlags = new _pypacker.default("I").unpack_from(header, 128)[0];
+    mobiHeader.exthFlags = (mobiHeader.exthFlags & 64) === 64 ? true : false;
+    _ref5 = new _pypacker.default("2H").unpack_from(header, 194);
+    mobiHeader.firstContentRecord = _ref5[0];
+    mobiHeader.lastContentRecord = _ref5[1];
+    this.info.title = new _pypacker.default(mobiHeader.fullNameLength + "s").unpack_from(header, mobiHeader.fullNameOffset)[0];
+    multibyte = 0;
+    trailers = 0;
+    if (mobiHeader.headerLength >= 228) {
+      flags = (_ref6 = new _pypacker.default("H").unpack_from(header, 242), mobiHeader.flags = _ref6[0], _ref6);
+      multibyte = flags & 1;
+      while (flags > 1) {
+        trailers += 1;
+        flags = flags & flags - 2;
+      }
+    }
+    for (position = _j = 1, _ref7 = mobiHeader.textRecordCount; 1 <= _ref7 ? _j <= _ref7 : _j >= _ref7; position = 1 <= _ref7 ? ++_j : --_j) {
+      data = buffer.slice(pdbHeader.records[position].position, pdbHeader.records[position + 1].position);
+      data = this.trim(data, trailers, multibyte);
+      if (mobiHeader.compression === 1) {
+        this.info.content += data;
+      } else if (mobiHeader.compression === 2) {
+        this.info.content += this.palmdocReader(data);
+      } else {
+        throw new Error("LZ77 compression isn't supported... yet.");
+      }
+    }
+    this.info.content = this.info.content.replace(/<(head|HEAD)>/g, '<head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>');
+    return this;
+  }
+  trim(data, trailers, multibyte) {
+    var end_bytes, num, v, z, _i, _j;
+    for (z = _i = 0; 0 <= trailers ? _i < trailers : _i > trailers; z = 0 <= trailers ? ++_i : --_i) {
+      num = 0;
+      end_bytes = data.slice(data.length - 4);
+      for (v = _j = 0; _j < 4; v = ++_j) {
+        if (end_bytes[v] & 128) {
+          num = 0;
+        }
+        num = num << 7 | end_bytes[v] & 127;
+      }
+      data = data.slice(0, data.length - num);
+    }
+    if (multibyte) {
+      num = (data[data.length - 1] & 3) + 1;
+      data = data.slice(0, data.length - num);
+    }
+    return data;
+  }
+  palmdocReader(data) {
+    var concat, distance, frame, index, length, string, x, _i, _j, _ref;
+    string = "";
+    index = 0;
+    while (index < data.length) {
+      frame = data[index];
+      index += 1;
+      if (frame >= 1 && frame <= 8) {
+        string += data.toString("utf8", index, index + frame);
+        for (x = _i = 0, _ref = frame - 1; 0 <= _ref ? _i < _ref : _i > _ref; x = 0 <= _ref ? ++_i : --_i) {
+          string += String.fromCharCode(57568);
+        }
+        index += frame;
+      } else if (frame < 128) {
+        string += String.fromCharCode(frame);
+      } else if (frame >= 192) {
+        string += " " + String.fromCharCode(frame ^ 128);
+      } else {
+        concat = frame << 8 | data[index];
+        distance = concat >> 3 & 2047;
+        length = (concat & 7) + 3;
+        if (length < distance) {
+          string += string.slice(-distance, length - distance);
+        } else {
+          for (x = _j = 0; 0 <= length ? _j < length : _j > length; x = 0 <= length ? ++_j : --_j) {
+            string += string[string.length - distance];
+          }
+        }
+        index += 1;
+      }
+    }
+    string = string.replace(/\uE0E0/g, "");
+    return string;
+  }
+}
+module.exports = Mobi;

package/lib/mobi.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export default class Mobi {
     filename: string;
     info: {
@@ -11,5 +10,5 @@ export default class Mobi {
     constructor(filename: string);
     parse(): this;
     trim(data: Buffer, trailers: number, multibyte: number): Buffer;
-    palmdocReader(data: Buffer): string;
+    palmdocReader(data: Buffer): any;
 }