You're Invited: Meet the Socket team at BSidesSF and RSAC - April 27 - May 1.RSVP →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@ridi/epub-parser

Package Overview
Dependencies
Maintainers
9
Versions
81
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@ridi/epub-parser - npm Package Compare versions

Comparing version

0.7.3-alpha.0
to
0.7.3-alpha.1

1421

lib/EpubParser.js
"use strict";
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _parserCore = require("@ridi/parser-core");

@@ -66,993 +42,626 @@

var _xmlLoader4 = _interopRequireWildcard(require("./loader/xmlLoader"));
var _xmlLoader = _interopRequireWildcard(require("./loader/xmlLoader"));
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
class EpubParser extends _parserCore.Parser {
static get parseDefaultOptions() {
return { ...super.parseDefaultOptions,
validatePackage: false,
allowNcxFileMissing: true,
parseStyle: true,
styleNamespacePrefix: 'ridi_style',
additionalInlineStyle: undefined
};
}
var EpubParser = function (_Parser) {
(0, _inherits2["default"])(EpubParser, _Parser);
static get parseOptionTypes() {
return { ...super.parseOptionTypes,
validatePackage: 'Boolean',
allowNcxFileMissing: 'Boolean',
parseStyle: 'Boolean',
styleNamespacePrefix: 'String',
additionalInlineStyle: 'String|Undefined'
};
}
var _super = _createSuper(EpubParser);
static get readDefaultOptions() {
return { ...super.readDefaultOptions,
basePath: undefined,
extractBody: false,
serializedAnchor: false,
ignoreScript: false,
removeAtrules: [],
removeTagSelector: [],
removeIdSelector: [],
removeClassSelector: []
};
}
(0, _createClass2["default"])(EpubParser, null, [{
key: "parseDefaultOptions",
get: function get() {
return _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(EpubParser), "parseDefaultOptions", this)), {}, {
validatePackage: false,
allowNcxFileMissing: true,
parseStyle: true,
styleNamespacePrefix: 'ridi_style',
additionalInlineStyle: undefined
});
}
}, {
key: "parseOptionTypes",
get: function get() {
return _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(EpubParser), "parseOptionTypes", this)), {}, {
validatePackage: 'Boolean',
allowNcxFileMissing: 'Boolean',
parseStyle: 'Boolean',
styleNamespacePrefix: 'String',
additionalInlineStyle: 'String|Undefined'
});
}
}, {
key: "readDefaultOptions",
get: function get() {
return _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(EpubParser), "readDefaultOptions", this)), {}, {
basePath: undefined,
extractBody: false,
serializedAnchor: false,
ignoreScript: false,
removeAtrules: [],
removeTagSelector: [],
removeIdSelector: [],
removeClassSelector: []
});
}
}, {
key: "readOptionTypes",
get: function get() {
return _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(EpubParser), "readOptionTypes", this)), {}, {
basePath: 'String|Undefined',
extractBody: 'Boolean|Function',
serializedAnchor: 'Boolean',
ignoreScript: 'Boolean',
removeAtrules: 'Array',
removeTagSelector: 'Array',
removeIdSelector: 'Array',
removeClassSelector: 'Array'
});
}
}]);
static get readOptionTypes() {
return { ...super.readOptionTypes,
basePath: 'String|Undefined',
extractBody: 'Boolean|Function',
serializedAnchor: 'Boolean',
ignoreScript: 'Boolean',
removeAtrules: 'Array',
removeTagSelector: 'Array',
removeIdSelector: 'Array',
removeClassSelector: 'Array'
};
}
function EpubParser(input, cryptoProvider, logLevel) {
(0, _classCallCheck2["default"])(this, EpubParser);
constructor(input, cryptoProvider, logLevel) {
logLevel = (0, _parserCore.isString)(cryptoProvider) ? cryptoProvider : logLevel;
cryptoProvider = (0, _parserCore.isString)(cryptoProvider) ? undefined : cryptoProvider;
return _super.call(this, input, cryptoProvider, {
super(input, cryptoProvider, {
namespace: 'EpubParser',
logLevel: logLevel
logLevel
});
}
(0, _createClass2["default"])(EpubParser, [{
key: "_getParseContextClass",
value: function _getParseContextClass() {
return _EpubParseContext["default"];
}
}, {
key: "_getBookClass",
value: function _getBookClass() {
return _EpubBook["default"];
}
}, {
key: "_getReadContextClass",
value: function _getReadContextClass() {
return _EpubReadContext["default"];
}
}, {
key: "_getReadItemClass",
value: function _getReadItemClass() {
return _BaseEpubItem["default"];
}
}, {
key: "_parseBeforeTasks",
value: function _parseBeforeTasks() {
return [{
fun: this._prepareParse,
name: 'prepareParse'
}, {
fun: this._validatePackageIfNeeded,
name: 'validatePackageIfNeeded'
}, {
fun: this._unzipIfNeeded,
name: 'unzipIfNeeded'
}];
}
}, {
key: "_parseTasks",
value: function _parseTasks() {
return [].concat((0, _toConsumableArray2["default"])((0, _get2["default"])((0, _getPrototypeOf2["default"])(EpubParser.prototype), "_parseTasks", this).call(this)), [{
fun: this._parseMetaInf,
name: 'parseMetaInf'
}, {
fun: this._parseOpf,
name: 'parseOpf'
}, {
fun: this._parseNcx,
name: 'parseNcx'
}]);
}
}, {
key: "_parseAfterTasks",
value: function _parseAfterTasks() {
return [].concat((0, _toConsumableArray2["default"])((0, _get2["default"])((0, _getPrototypeOf2["default"])(EpubParser.prototype), "_parseAfterTasks", this).call(this)), [{
fun: this._checkResult,
name: 'checkResult'
}]);
}
}, {
key: "_validatePackageIfNeeded",
value: function () {
var _validatePackageIfNeeded2 = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee(context) {
var entries, options, firstEntry, signature, reason, _reason;
_getParseContextClass() {
return _EpubParseContext.default;
}
return _regenerator["default"].wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
entries = context.entries, options = context.options;
_getBookClass() {
return _EpubBook.default;
}
if (!(!(0, _parserCore.isString)(entries.source) && options.validatePackage)) {
_context.next = 22;
break;
}
_getReadContextClass() {
return _EpubReadContext.default;
}
firstEntry = context.entries.first;
_context.next = 5;
return firstEntry.getFile({
encoding: 'utf8'
});
_getReadItemClass() {
return _BaseEpubItem.default;
}
case 5:
signature = _context.sent;
_parseBeforeTasks() {
return [{
fun: this._prepareParse,
name: 'prepareParse'
}, {
fun: this._validatePackageIfNeeded,
name: 'validatePackageIfNeeded'
}, {
fun: this._unzipIfNeeded,
name: 'unzipIfNeeded'
}];
}
if (!(firstEntry.entryPath !== 'mimetype')) {
_context.next = 10;
break;
}
_parseTasks() {
return [...super._parseTasks(), {
fun: this._parseMetaInf,
name: 'parseMetaInf'
}, {
fun: this._parseOpf,
name: 'parseOpf'
}, {
fun: this._parseNcx,
name: 'parseNcx'
}];
}
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', 'mimetype file must be first file in archive.');
_parseAfterTasks() {
return [...super._parseAfterTasks(), {
fun: this._checkResult,
name: 'checkResult'
}];
}
case 10:
if (!(firstEntry.method !== 0)) {
_context.next = 14;
break;
}
async _validatePackageIfNeeded(context) {
const {
entries,
options
} = context;
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', 'mimetype file should not compressed.');
if (!(0, _parserCore.isString)(entries.source) && options.validatePackage) {
const firstEntry = context.entries.first;
const signature = await firstEntry.getFile({
encoding: 'utf8'
});
case 14:
if (!(signature !== 'application/epub+zip')) {
_context.next = 19;
break;
}
reason = 'mimetype file should only contain string \'application/epub+zip\'.';
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', reason);
case 19:
if (!(firstEntry.extraFieldLength > 0)) {
_context.next = 22;
break;
}
_reason = 'shouldn\'t use extra field feature of ZIP format for mimetype file.';
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', _reason);
case 22:
return _context.abrupt("return", context);
case 23:
case "end":
return _context.stop();
}
}
}, _callee);
}));
function _validatePackageIfNeeded(_x) {
return _validatePackageIfNeeded2.apply(this, arguments);
if (firstEntry.entryPath !== 'mimetype') {
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', 'mimetype file must be first file in archive.');
} else if (firstEntry.method !== 0) {
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', 'mimetype file should not compressed.');
} else if (signature !== 'application/epub+zip') {
const reason = 'mimetype file should only contain string \'application/epub+zip\'.';
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', reason);
} else if (firstEntry.extraFieldLength > 0) {
const reason = 'shouldn\'t use extra field feature of ZIP format for mimetype file.';
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'package', 'reason', reason);
}
}
return _validatePackageIfNeeded;
}()
}, {
key: "_parseMetaInf",
value: function () {
var _parseMetaInf2 = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee2(context) {
var entryPath, containerEntry, _xmlLoader, container, rootfiles, rootfile, opfPath;
return context;
}
return _regenerator["default"].wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
entryPath = 'META-INF/container.xml';
containerEntry = context.entries.find(entryPath);
async _parseMetaInf(context) {
const entryPath = 'META-INF/container.xml';
const containerEntry = context.entries.find(entryPath);
if ((0, _parserCore.isExists)(containerEntry)) {
_context2.next = 4;
break;
}
if (!(0, _parserCore.isExists)(containerEntry)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, entryPath);
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, entryPath);
const {
container
} = (0, _xmlLoader.default)(await containerEntry.getFile({
encoding: 'utf8'
}));
case 4:
_context2.t0 = _xmlLoader4["default"];
_context2.next = 7;
return containerEntry.getFile({
encoding: 'utf8'
});
if (!(0, _parserCore.isExists)(container)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'container', entryPath);
}
case 7:
_context2.t1 = _context2.sent;
_xmlLoader = (0, _context2.t0)(_context2.t1);
container = _xmlLoader.container;
if (!(0, _parserCore.isExists)(container.rootfiles)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'rootfiles', entryPath);
}
if ((0, _parserCore.isExists)(container)) {
_context2.next = 12;
break;
}
const {
rootfiles
} = container;
const rootfile = ((0, _parserCore.isArray)(rootfiles.rootfile) ? rootfiles.rootfile : [rootfiles.rootfile]).find(item => {
return item['media-type'] === 'application/oebps-package+xml';
});
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'container', entryPath);
if (!(0, _parserCore.isExists)(rootfile)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'rootfile', entryPath);
}
case 12:
if ((0, _parserCore.isExists)(container.rootfiles)) {
_context2.next = 14;
break;
}
const opfPath = rootfile['full-path'];
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'rootfiles', entryPath);
if (!(0, _parserCore.isExists)(opfPath)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOATTR, 'rootfile', 'full-path', entryPath);
}
case 14:
rootfiles = container.rootfiles;
rootfile = ((0, _parserCore.isArray)(rootfiles.rootfile) ? rootfiles.rootfile : [rootfiles.rootfile]).find(function (item) {
return item['media-type'] === 'application/oebps-package+xml';
});
context.opfPath = (0, _parserCore.safePath)(opfPath);
context.basePath = (0, _parserCore.safeDirname)(opfPath);
return context;
}
if ((0, _parserCore.isExists)(rootfile)) {
_context2.next = 18;
break;
}
async _parseOpf(context) {
const {
entries,
opfPath
} = context;
const opfEntry = entries.find(opfPath, false);
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'rootfile', entryPath);
if (!(0, _parserCore.isExists)(opfEntry)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, opfPath);
}
case 18:
opfPath = rootfile['full-path'];
const {
package: root
} = (0, _xmlLoader.default)(await opfEntry.getFile({
encoding: 'utf8'
}));
if ((0, _parserCore.isExists)(opfPath)) {
_context2.next = 21;
break;
}
if (!(0, _parserCore.isExists)(root)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'package', opfPath);
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOATTR, 'rootfile', 'full-path', entryPath);
if (!(0, _parserCore.isExists)(root.metadata) || !(0, _parserCore.isExists)(root.manifest) || !(0, _parserCore.isExists)(root.spine)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'metadata or manifest or spine', opfPath);
}
case 21:
context.opfPath = (0, _parserCore.safePath)(opfPath);
context.basePath = (0, _parserCore.safeDirname)(opfPath);
return _context2.abrupt("return", context);
context.rawBook.version = root.version;
context = await this._parseMetadata(root.metadata, context);
context = await this._parseManifestAndSpine(root.manifest, root.spine, context);
context = await this._parseGuide(root.guide, context);
return context;
}
case 24:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
_parseMetadata(metadata, context) {
return new Promise(resolve => {
const {
rawBook
} = context;
const {
title,
creator,
subject,
description,
publisher,
contributor,
date,
type,
format,
identifier,
source,
language,
relation,
coverage,
rights,
meta
} = metadata;
rawBook.titles = (0, _xmlLoader.getValues)(title, key => key === _xmlLoader.textNodeName ? 'name' : key);
rawBook.creators = (0, _xmlLoader.getValues)(creator, key => key === _xmlLoader.textNodeName ? 'name' : key);
rawBook.subjects = (0, _xmlLoader.getValues)(subject);
rawBook.description = (0, _xmlLoader.getValue)(description);
rawBook.publisher = (0, _xmlLoader.getValue)(publisher);
rawBook.contributors = (0, _xmlLoader.getValues)(contributor, key => key === _xmlLoader.textNodeName ? 'name' : key);
rawBook.dates = (0, _xmlLoader.getValues)(date, key => key === _xmlLoader.textNodeName ? 'value' : key);
rawBook.type = (0, _xmlLoader.getValue)(type);
rawBook.format = (0, _xmlLoader.getValue)(format);
rawBook.identifiers = (0, _xmlLoader.getValues)(identifier, key => key === _xmlLoader.textNodeName ? 'value' : key);
rawBook.source = (0, _xmlLoader.getValue)(source);
rawBook.languages = (0, _xmlLoader.getValues)(language);
rawBook.relation = (0, _xmlLoader.getValue)(relation);
rawBook.coverage = (0, _xmlLoader.getValue)(coverage);
rawBook.rights = (0, _xmlLoader.getValue)(rights);
rawBook.metas = (0, _xmlLoader.getValues)(meta);
resolve(context);
});
}
function _parseMetaInf(_x2) {
return _parseMetaInf2.apply(this, arguments);
}
async _parseManifestAndSpine(manifest, spine, context) {
const {
rawBook,
basePath,
options,
entries
} = context;
const {
toc: tocId
} = spine;
const items = (0, _xmlLoader.getValues)(manifest.item);
const itemRefs = (0, _xmlLoader.getValues)(spine.itemref);
const coverMeta = rawBook.metas.find(item => (0, _parserCore.isExists)(item.name) && item.name.toLowerCase() === 'cover');
let inlineStyles = [];
rawBook.items = [];
await items.reduce((prevPromise, item, idx) => {
return prevPromise.then(async () => {
const rawItem = {};
rawItem.id = item.id;
return _parseMetaInf;
}()
}, {
key: "_parseOpf",
value: function () {
var _parseOpf2 = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee3(context) {
var _context3, entries, opfPath, opfEntry, _xmlLoader2, root;
if ((0, _parserCore.isExists)(item.href)) {
rawItem.href = (0, _parserCore.safePathJoin)(basePath, item.href);
}
return _regenerator["default"].wrap(function _callee3$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
_context3 = context, entries = _context3.entries, opfPath = _context3.opfPath;
opfEntry = entries.find(opfPath, false);
rawItem.mediaType = item['media-type'];
rawItem.itemType = this.getItemTypeFromMediaType(rawItem.mediaType);
if ((0, _parserCore.isExists)(opfEntry)) {
_context4.next = 4;
break;
}
if (rawItem.itemType === _DeadItem.default) {
rawItem.reason = _DeadItem.default.Reason.NOT_SUPPORT_TYPE;
this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, opfPath);
const itemEntry = entries.find(rawItem.href, false);
case 4:
_context4.t0 = _xmlLoader4["default"];
_context4.next = 7;
return opfEntry.getFile({
encoding: 'utf8'
});
if ((0, _parserCore.isExists)(itemEntry)) {
rawItem.size = itemEntry.size;
case 7:
_context4.t1 = _context4.sent;
_xmlLoader2 = (0, _context4.t0)(_context4.t1);
root = _xmlLoader2["package"];
if (rawItem.itemType === _SpineItem.default) {
const refIndex = itemRefs.findIndex(itemRef => itemRef.idref === rawItem.id);
if ((0, _parserCore.isExists)(root)) {
_context4.next = 12;
break;
}
if (refIndex >= 0) {
const ref = itemRefs[refIndex];
rawItem.isLinear = (0, _parserCore.isExists)(ref.linear) ? (0, _parserCore.parseBool)(ref.linear) : true;
rawItem.index = refIndex;
} else {
rawItem.itemType = _DeadItem.default;
rawItem.reason = _DeadItem.default.Reason.NOT_SPINE;
this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
}
} else if (rawItem.itemType === _ImageItem.default) {
if (!context.foundCover) {
if ((0, _parserCore.isExists)(coverMeta) && rawItem.id === coverMeta.content) {
rawItem.isCover = true;
context.foundCover = true;
} else if (rawItem.id.toLowerCase() === 'cover') {
rawItem.isCover = true;
context.foundCover = true;
}
}
} else if (rawItem.itemType === _NcxItem.default) {
if (rawItem.id !== tocId) {
rawItem.itemType = _DeadItem.default;
rawItem.reason = _DeadItem.default.Reason.NOT_NCX;
this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
}
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'package', opfPath);
case 12:
if (!(!(0, _parserCore.isExists)(root.metadata) || !(0, _parserCore.isExists)(root.manifest) || !(0, _parserCore.isExists)(root.spine))) {
_context4.next = 14;
break;
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'metadata or manifest or spine', opfPath);
case 14:
context.rawBook.version = root.version;
_context4.next = 17;
return this._parseMetadata(root.metadata, context);
case 17:
context = _context4.sent;
_context4.next = 20;
return this._parseManifestAndSpine(root.manifest, root.spine, context);
case 20:
context = _context4.sent;
_context4.next = 23;
return this._parseGuide(root.guide, context);
case 23:
context = _context4.sent;
return _context4.abrupt("return", context);
case 25:
case "end":
return _context4.stop();
if (options.parseStyle) {
if (rawItem.itemType === _CssItem.default) {
rawItem.namespace = `${options.styleNamespacePrefix}${idx}`;
} else if (rawItem.itemType === _SpineItem.default) {
const result = await this._parseSpineStyle(rawItem, itemEntry, options);
rawItem.styles = result.styles;
inlineStyles = inlineStyles.concat(result.inlineStyles);
}
}
}, _callee3, this);
}));
} else {
rawItem.itemType = _DeadItem.default;
rawItem.reason = _DeadItem.default.Reason.NOT_EXISTS;
this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
}
function _parseOpf(_x3) {
return _parseOpf2.apply(this, arguments);
}
rawBook.items.push(rawItem);
});
}, Promise.resolve());
const {
additionalInlineStyle: userStyle
} = options;
return _parseOpf;
}()
}, {
key: "_parseMetadata",
value: function _parseMetadata(metadata, context) {
return new Promise(function (resolve) {
var rawBook = context.rawBook;
var title = metadata.title,
creator = metadata.creator,
subject = metadata.subject,
description = metadata.description,
publisher = metadata.publisher,
contributor = metadata.contributor,
date = metadata.date,
type = metadata.type,
format = metadata.format,
identifier = metadata.identifier,
source = metadata.source,
language = metadata.language,
relation = metadata.relation,
coverage = metadata.coverage,
rights = metadata.rights,
meta = metadata.meta;
rawBook.titles = (0, _xmlLoader4.getValues)(title, function (key) {
return key === _xmlLoader4.textNodeName ? 'name' : key;
});
rawBook.creators = (0, _xmlLoader4.getValues)(creator, function (key) {
return key === _xmlLoader4.textNodeName ? 'name' : key;
});
rawBook.subjects = (0, _xmlLoader4.getValues)(subject);
rawBook.description = (0, _xmlLoader4.getValue)(description);
rawBook.publisher = (0, _xmlLoader4.getValue)(publisher);
rawBook.contributors = (0, _xmlLoader4.getValues)(contributor, function (key) {
return key === _xmlLoader4.textNodeName ? 'name' : key;
});
rawBook.dates = (0, _xmlLoader4.getValues)(date, function (key) {
return key === _xmlLoader4.textNodeName ? 'value' : key;
});
rawBook.type = (0, _xmlLoader4.getValue)(type);
rawBook.format = (0, _xmlLoader4.getValue)(format);
rawBook.identifiers = (0, _xmlLoader4.getValues)(identifier, function (key) {
return key === _xmlLoader4.textNodeName ? 'value' : key;
});
rawBook.source = (0, _xmlLoader4.getValue)(source);
rawBook.languages = (0, _xmlLoader4.getValues)(language);
rawBook.relation = (0, _xmlLoader4.getValue)(relation);
rawBook.coverage = (0, _xmlLoader4.getValue)(coverage);
rawBook.rights = (0, _xmlLoader4.getValue)(rights);
rawBook.metas = (0, _xmlLoader4.getValues)(meta);
resolve(context);
if ((0, _parserCore.isExists)(userStyle)) {
const namespace = `${options.styleNamespacePrefix}${inlineStyles.length}`;
const id = `additional_inline_style_${namespace}`;
inlineStyles.push({
id,
href: `${basePath}/${id}`,
mediaType: 'text/css',
size: userStyle.length,
itemType: _InlineCssItem.default,
namespace,
style: userStyle
});
}
}, {
key: "_parseManifestAndSpine",
value: function () {
var _parseManifestAndSpine2 = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee5(manifest, spine, context) {
var _this = this;
var rawBook, basePath, options, entries, tocId, items, itemRefs, coverMeta, inlineStyles, userStyle, namespace, id;
return _regenerator["default"].wrap(function _callee5$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
rawBook = context.rawBook, basePath = context.basePath, options = context.options, entries = context.entries;
tocId = spine.toc;
items = (0, _xmlLoader4.getValues)(manifest.item);
itemRefs = (0, _xmlLoader4.getValues)(spine.itemref);
coverMeta = rawBook.metas.find(function (item) {
return (0, _parserCore.isExists)(item.name) && item.name.toLowerCase() === 'cover';
});
inlineStyles = [];
rawBook.items = [];
_context6.next = 9;
return items.reduce(function (prevPromise, item, idx) {
return prevPromise.then((0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee4() {
var rawItem, itemEntry, refIndex, ref, result;
return _regenerator["default"].wrap(function _callee4$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
rawItem = {};
rawItem.id = item.id;
rawBook.items = [...rawBook.items, ...inlineStyles];
return context;
}
if ((0, _parserCore.isExists)(item.href)) {
rawItem.href = (0, _parserCore.safePathJoin)(basePath, item.href);
}
async _parseSpineStyle(rawItem, entry, options) {
const styles = [];
const inlineStyles = [];
rawItem.mediaType = item['media-type'];
rawItem.itemType = _this.getItemTypeFromMediaType(rawItem.mediaType);
const find = (list, property, value) => list.find(item => item[property] === value);
if (rawItem.itemType === _DeadItem["default"]) {
rawItem.reason = _DeadItem["default"].Reason.NOT_SUPPORT_TYPE;
const filter = (list, property, value) => list.filter(item => item[property] === value);
_this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
}
const document = (0, _himalaya.parse)(await entry.getFile({
encoding: 'utf8'
}));
const html = find(document, 'tagName', 'html');
itemEntry = entries.find(rawItem.href, false);
if (!(0, _parserCore.isExists)(html)) {
this.logger.error(`Can not analyze style in '${rawItem.href}'. (reason: no html tag)`);
return {
styles,
inlineStyles
};
}
if (!(0, _parserCore.isExists)(itemEntry)) {
_context5.next = 23;
break;
}
const head = find(html.children, 'tagName', 'head');
rawItem.size = itemEntry.size;
if (!(0, _parserCore.isExists)(head)) {
this.logger.error(`Can not analyze style in '${rawItem.href}'. (reason: no head tag)`);
return {
styles,
inlineStyles
};
}
if (rawItem.itemType === _SpineItem["default"]) {
refIndex = itemRefs.findIndex(function (itemRef) {
return itemRef.idref === rawItem.id;
});
filter(head.children, 'tagName', 'link').forEach(link => {
const {
attributes: attrs
} = link;
if (refIndex >= 0) {
ref = itemRefs[refIndex];
rawItem.isLinear = (0, _parserCore.isExists)(ref.linear) ? (0, _parserCore.parseBool)(ref.linear) : true;
rawItem.index = refIndex;
} else {
rawItem.itemType = _DeadItem["default"];
rawItem.reason = _DeadItem["default"].Reason.NOT_SPINE;
if ((0, _parserCore.isExists)(attrs)) {
const rel = find(attrs, 'key', 'rel');
const type = find(attrs, 'key', 'type');
_this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
}
} else if (rawItem.itemType === _ImageItem["default"]) {
if (!context.foundCover) {
if ((0, _parserCore.isExists)(coverMeta) && rawItem.id === coverMeta.content) {
rawItem.isCover = true;
context.foundCover = true;
} else if (rawItem.id.toLowerCase() === 'cover') {
rawItem.isCover = true;
context.foundCover = true;
}
}
} else if (rawItem.itemType === _NcxItem["default"]) {
if (rawItem.id !== tocId) {
rawItem.itemType = _DeadItem["default"];
rawItem.reason = _DeadItem["default"].Reason.NOT_NCX;
if ((0, _parserCore.isExists)(rel) && rel.value === 'stylesheet' || (0, _parserCore.isExists)(type) && type.value === 'text/css') {
const href = find(attrs, 'key', 'href');
_this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
}
}
if ((0, _parserCore.isExists)(href) && (0, _parserCore.isExists)(href.value) && !(0, _parserCore.isUrl)(href.value)) {
styles.push((0, _parserCore.safePathJoin)((0, _parserCore.safeDirname)(rawItem.href), href.value));
}
}
}
});
filter(head.children, 'tagName', 'style').forEach((style, idx) => {
const firstNode = style.children[0];
if (!options.parseStyle) {
_context5.next = 21;
break;
}
if ((0, _parserCore.isExists)(firstNode)) {
const namespace = `${options.styleNamespacePrefix}${idx}`;
const href = `${rawItem.href}_${namespace}`;
const {
content
} = firstNode;
const inlineStyleItem = {
id: `${rawItem.id}_${namespace}`,
href,
mediaType: 'text/css',
size: content.length,
itemType: _InlineCssItem.default,
namespace,
style: content
};
styles.push(inlineStyleItem.href);
inlineStyles.push(inlineStyleItem);
}
});
return {
styles,
inlineStyles
};
}
if (!(rawItem.itemType === _CssItem["default"])) {
_context5.next = 15;
break;
}
_parseGuide(guide, context) {
return new Promise(resolve => {
const {
rawBook
} = context;
let {
foundCover
} = context;
rawBook.guides = [];
rawItem.namespace = "".concat(options.styleNamespacePrefix).concat(idx);
_context5.next = 21;
break;
if ((0, _parserCore.isExists)(guide)) {
(0, _xmlLoader.getValues)(guide.reference).forEach(reference => {
reference = (0, _parserCore.mergeObjects)(reference, {
href: (0, _parserCore.safePathJoin)(context.basePath, reference.href)
});
case 15:
if (!(rawItem.itemType === _SpineItem["default"])) {
_context5.next = 21;
break;
}
if (!foundCover && (0, _parserCore.isExists)(reference.type) && reference.type.toLowerCase() === _Guide.default.Types.COVER) {
const imageItem = rawBook.items.find(item => item.itemType === _ImageItem.default && item.href === reference.href);
_context5.next = 18;
return _this._parseSpineStyle(rawItem, itemEntry, options);
case 18:
result = _context5.sent;
rawItem.styles = result.styles;
inlineStyles = inlineStyles.concat(result.inlineStyles);
case 21:
_context5.next = 26;
break;
case 23:
rawItem.itemType = _DeadItem["default"];
rawItem.reason = _DeadItem["default"].Reason.NOT_EXISTS;
_this.logger.warn('Referenced resource \'%s\' ignored. (reason: %s)', rawItem.id, rawItem.reason);
case 26:
rawBook.items.push(rawItem);
case 27:
case "end":
return _context5.stop();
}
}
}, _callee4);
})));
}, Promise.resolve());
case 9:
userStyle = options.additionalInlineStyle;
if ((0, _parserCore.isExists)(userStyle)) {
namespace = "".concat(options.styleNamespacePrefix).concat(inlineStyles.length);
id = "additional_inline_style_".concat(namespace);
inlineStyles.push({
id: id,
href: "".concat(basePath, "/").concat(id),
mediaType: 'text/css',
size: userStyle.length,
itemType: _InlineCssItem["default"],
namespace: namespace,
style: userStyle
});
}
rawBook.items = [].concat((0, _toConsumableArray2["default"])(rawBook.items), (0, _toConsumableArray2["default"])(inlineStyles));
return _context6.abrupt("return", context);
case 13:
case "end":
return _context6.stop();
if ((0, _parserCore.isExists)(imageItem)) {
imageItem.isCover = true;
foundCover = true;
}
}
}, _callee5);
}));
function _parseManifestAndSpine(_x4, _x5, _x6) {
return _parseManifestAndSpine2.apply(this, arguments);
rawBook.guides.push(reference);
});
}
return _parseManifestAndSpine;
}()
}, {
key: "_parseSpineStyle",
value: function () {
var _parseSpineStyle2 = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee6(rawItem, entry, options) {
var styles, inlineStyles, find, filter, document, html, head;
return _regenerator["default"].wrap(function _callee6$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
styles = [];
inlineStyles = [];
resolve(context);
});
}
find = function find(list, property, value) {
return list.find(function (item) {
return item[property] === value;
});
};
async _parseNcx(context) {
const {
rawBook,
entries,
options
} = context;
const {
allowNcxFileMissing
} = options;
const ncxItem = rawBook.items.find(item => item.itemType === _NcxItem.default);
filter = function filter(list, property, value) {
return list.filter(function (item) {
return item[property] === value;
});
};
_context7.t0 = _himalaya.parse;
_context7.next = 7;
return entry.getFile({
encoding: 'utf8'
});
case 7:
_context7.t1 = _context7.sent;
document = (0, _context7.t0)(_context7.t1);
html = find(document, 'tagName', 'html');
if ((0, _parserCore.isExists)(html)) {
_context7.next = 13;
break;
}
this.logger.error("Can not analyze style in '".concat(rawItem.href, "'. (reason: no html tag)"));
return _context7.abrupt("return", {
styles: styles,
inlineStyles: inlineStyles
});
case 13:
head = find(html.children, 'tagName', 'head');
if ((0, _parserCore.isExists)(head)) {
_context7.next = 17;
break;
}
this.logger.error("Can not analyze style in '".concat(rawItem.href, "'. (reason: no head tag)"));
return _context7.abrupt("return", {
styles: styles,
inlineStyles: inlineStyles
});
case 17:
filter(head.children, 'tagName', 'link').forEach(function (link) {
var attrs = link.attributes;
if ((0, _parserCore.isExists)(attrs)) {
var rel = find(attrs, 'key', 'rel');
var type = find(attrs, 'key', 'type');
if ((0, _parserCore.isExists)(rel) && rel.value === 'stylesheet' || (0, _parserCore.isExists)(type) && type.value === 'text/css') {
var href = find(attrs, 'key', 'href');
if ((0, _parserCore.isExists)(href) && (0, _parserCore.isExists)(href.value) && !(0, _parserCore.isUrl)(href.value)) {
styles.push((0, _parserCore.safePathJoin)((0, _parserCore.safeDirname)(rawItem.href), href.value));
}
}
}
});
filter(head.children, 'tagName', 'style').forEach(function (style, idx) {
var firstNode = style.children[0];
if ((0, _parserCore.isExists)(firstNode)) {
var namespace = "".concat(options.styleNamespacePrefix).concat(idx);
var href = "".concat(rawItem.href, "_").concat(namespace);
var content = firstNode.content;
var inlineStyleItem = {
id: "".concat(rawItem.id, "_").concat(namespace),
href: href,
mediaType: 'text/css',
size: content.length,
itemType: _InlineCssItem["default"],
namespace: namespace,
style: content
};
styles.push(inlineStyleItem.href);
inlineStyles.push(inlineStyleItem);
}
});
return _context7.abrupt("return", {
styles: styles,
inlineStyles: inlineStyles
});
case 20:
case "end":
return _context7.stop();
}
}
}, _callee6, this);
if ((0, _parserCore.isExists)(ncxItem)) {
const ncxEntry = entries.find(ncxItem.href, false);
const {
ncx
} = (0, _xmlLoader.default)(await ncxEntry.getFile({
encoding: 'utf8'
}));
function _parseSpineStyle(_x7, _x8, _x9) {
return _parseSpineStyle2.apply(this, arguments);
if (!(0, _parserCore.isExists)(ncx)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'ncx', ncxItem.href);
}
return _parseSpineStyle;
}()
}, {
key: "_parseGuide",
value: function _parseGuide(guide, context) {
return new Promise(function (resolve) {
var rawBook = context.rawBook;
var foundCover = context.foundCover;
rawBook.guides = [];
if (!(0, _parserCore.isExists)(ncx.navMap)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'navMap', ncxItem.href);
}
if ((0, _parserCore.isExists)(guide)) {
(0, _xmlLoader4.getValues)(guide.reference).forEach(function (reference) {
reference = (0, _parserCore.mergeObjects)(reference, {
href: (0, _parserCore.safePathJoin)(context.basePath, reference.href)
});
ncxItem.navPoints = [];
if (!foundCover && (0, _parserCore.isExists)(reference.type) && reference.type.toLowerCase() === _Guide["default"].Types.COVER) {
var imageItem = rawBook.items.find(function (item) {
return item.itemType === _ImageItem["default"] && item.href === reference.href;
});
if ((0, _parserCore.isExists)(imageItem)) {
imageItem.isCover = true;
foundCover = true;
}
}
rawBook.guides.push(reference);
const normalizeSrc = np => {
if ((0, _parserCore.isExists)(np.children)) {
np.children.forEach((child, idx) => {
np.children[idx] = normalizeSrc(child);
});
}
resolve(context);
});
}
}, {
key: "_parseNcx",
value: function () {
var _parseNcx2 = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee7(context) {
var _this2 = this;
np.content.src = (0, _parserCore.safePathJoin)(context.basePath, np.content.src);
return np;
};
var rawBook, entries, options, allowNcxFileMissing, ncxItem, ncxEntry, _xmlLoader3, ncx, normalizeSrc, keyTranslator, prevNcxItem;
const keyTranslator = key => key === 'navPoint' ? 'children' : key;
return _regenerator["default"].wrap(function _callee7$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
rawBook = context.rawBook, entries = context.entries, options = context.options;
allowNcxFileMissing = options.allowNcxFileMissing;
ncxItem = rawBook.items.find(function (item) {
return item.itemType === _NcxItem["default"];
});
(0, _xmlLoader.getValues)(ncx.navMap.navPoint, keyTranslator).forEach(navPoint => {
const {
id,
content
} = navPoint;
if (!(0, _parserCore.isExists)(ncxItem)) {
_context8.next = 21;
break;
}
if ((0, _parserCore.isExists)(id) && (0, _parserCore.isExists)(content) && (0, _parserCore.isExists)(content.src) && content.src.length > 0) {
ncxItem.navPoints.push(normalizeSrc(navPoint));
} else {
this.logger.warn('NavPoint \'%s\' ignored. (reason: \'id\' or \'content.src\' is not defined)', navPoint.id);
}
});
} else if (!allowNcxFileMissing) {
const prevNcxItem = rawBook.items.find(item => {
return this.getItemTypeFromMediaType(item.mediaType) === _NcxItem.default && item.itemType === _DeadItem.default;
});
ncxEntry = entries.find(ncxItem.href, false);
_context8.t0 = _xmlLoader4["default"];
_context8.next = 8;
return ncxEntry.getFile({
encoding: 'utf8'
});
case 8:
_context8.t1 = _context8.sent;
_xmlLoader3 = (0, _context8.t0)(_context8.t1);
ncx = _xmlLoader3.ncx;
if ((0, _parserCore.isExists)(ncx)) {
_context8.next = 13;
break;
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'ncx', ncxItem.href);
case 13:
if ((0, _parserCore.isExists)(ncx.navMap)) {
_context8.next = 15;
break;
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOELMT, 'navMap', ncxItem.href);
case 15:
ncxItem.navPoints = [];
normalizeSrc = function normalizeSrc(np) {
if ((0, _parserCore.isExists)(np.children)) {
np.children.forEach(function (child, idx) {
np.children[idx] = normalizeSrc(child);
});
}
np.content.src = (0, _parserCore.safePathJoin)(context.basePath, np.content.src);
return np;
};
keyTranslator = function keyTranslator(key) {
return key === 'navPoint' ? 'children' : key;
};
(0, _xmlLoader4.getValues)(ncx.navMap.navPoint, keyTranslator).forEach(function (navPoint) {
var id = navPoint.id,
content = navPoint.content;
if ((0, _parserCore.isExists)(id) && (0, _parserCore.isExists)(content) && (0, _parserCore.isExists)(content.src) && content.src.length > 0) {
ncxItem.navPoints.push(normalizeSrc(navPoint));
} else {
_this2.logger.warn('NavPoint \'%s\' ignored. (reason: \'id\' or \'content.src\' is not defined)', navPoint.id);
}
});
_context8.next = 26;
break;
case 21:
if (allowNcxFileMissing) {
_context8.next = 26;
break;
}
prevNcxItem = rawBook.items.find(function (item) {
return _this2.getItemTypeFromMediaType(item.mediaType) === _NcxItem["default"] && item.itemType === _DeadItem["default"];
});
if (!(0, _parserCore.isExists)(prevNcxItem)) {
_context8.next = 25;
break;
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, prevNcxItem.href);
case 25:
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'opf', 'reason', 'can not found ncx attribute');
case 26:
return _context8.abrupt("return", context);
case 27:
case "end":
return _context8.stop();
}
}
}, _callee7);
}));
function _parseNcx(_x10) {
return _parseNcx2.apply(this, arguments);
if ((0, _parserCore.isExists)(prevNcxItem)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, prevNcxItem.href);
}
return _parseNcx;
}()
}, {
key: "_checkResult",
value: function _checkResult(book) {
if (!(0, _parserCore.isExists)(book.cover)) {
this.logger.warn('Cover image not found in EPUB.');
}
throw (0, _parserCore.createError)(_parserCore.Errors.EINVAL, 'opf', 'reason', 'can not found ncx attribute');
}
if (!(0, _parserCore.isExists)(book.ncx)) {
this.logger.warn('NCX not found in EPUB.');
}
return context;
}
return book;
_checkResult(book) {
if (!(0, _parserCore.isExists)(book.cover)) {
this.logger.warn('Cover image not found in EPUB.');
}
}, {
key: "_read",
value: function () {
var _read2 = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee9(context) {
var items, entries, options, results;
return _regenerator["default"].wrap(function _callee9$(_context10) {
while (1) {
switch (_context10.prev = _context10.next) {
case 0:
items = context.items, entries = context.entries, options = context.options;
results = [];
_context10.next = 4;
return items.reduce(function (prevPromise, item) {
return prevPromise.then((0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee8() {
var entry, file;
return _regenerator["default"].wrap(function _callee8$(_context9) {
while (1) {
switch (_context9.prev = _context9.next) {
case 0:
if (!(item instanceof _InlineCssItem["default"])) {
_context9.next = 3;
break;
}
results.push((0, _cssLoader["default"])(item, item.style, options));
return _context9.abrupt("return");
if (!(0, _parserCore.isExists)(book.ncx)) {
this.logger.warn('NCX not found in EPUB.');
}
case 3:
entry = entries.find(item.href, false);
return book;
}
if (!(!options.force && !(0, _parserCore.isExists)(entry))) {
_context9.next = 6;
break;
}
async _read(context) {
const {
items,
entries,
options
} = context;
const results = [];
await items.reduce((prevPromise, item) => {
return prevPromise.then(async () => {
if (item instanceof _InlineCssItem.default) {
results.push((0, _cssLoader.default)(item, item.style, options));
return;
}
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, item.href);
const entry = entries.find(item.href, false);
case 6:
_context9.next = 8;
return entry.getFile({
encoding: item.defaultEncoding
});
if (!options.force && !(0, _parserCore.isExists)(entry)) {
throw (0, _parserCore.createError)(_parserCore.Errors.ENOFILE, item.href);
}
case 8:
file = _context9.sent;
const file = await entry.getFile({
encoding: item.defaultEncoding
});
if (item instanceof _SpineItem["default"]) {
results.push((0, _spineLoader["default"])(item, file, options));
} else if (item instanceof _CssItem["default"]) {
results.push((0, _cssLoader["default"])(item, file, options));
} else {
results.push(file);
}
if (item instanceof _SpineItem.default) {
results.push((0, _spineLoader.default)(item, file, options));
} else if (item instanceof _CssItem.default) {
results.push((0, _cssLoader.default)(item, file, options));
} else {
results.push(file);
}
});
}, Promise.resolve());
return results;
}
case 10:
case "end":
return _context9.stop();
}
}
}, _callee8);
})));
}, Promise.resolve());
getItemTypeFromMediaType(mediaType) {
const types = {
'application/font': _FontItem.default,
'application/font-otf': _FontItem.default,
'application/font-sfnt': _FontItem.default,
'application/font-woff': _FontItem.default,
'application/vnd.ms-opentype': _FontItem.default,
'application/x-font-ttf': _FontItem.default,
'application/x-font-truetype': _FontItem.default,
'application/x-font-opentype': _FontItem.default,
'font/opentype': _FontItem.default,
'font/otf': _FontItem.default,
'font/woff2': _FontItem.default,
'application/x-dtbncx+xml': _NcxItem.default,
'application/xhtml+xml': _SpineItem.default,
'text/css': _CssItem.default,
'image/gif': _ImageItem.default,
'image/jpeg': _ImageItem.default,
'image/png': _ImageItem.default,
'image/bmp': _ImageItem.default,
'image/svg+xml': _SvgItem.default
};
const type = types[mediaType.toLowerCase()];
return (0, _parserCore.isExists)(type) ? type : _DeadItem.default;
}
case 4:
return _context10.abrupt("return", results);
}
case 5:
case "end":
return _context10.stop();
}
}
}, _callee9);
}));
function _read(_x11) {
return _read2.apply(this, arguments);
}
return _read;
}()
}, {
key: "getItemTypeFromMediaType",
value: function getItemTypeFromMediaType(mediaType) {
var types = {
'application/font': _FontItem["default"],
'application/font-otf': _FontItem["default"],
'application/font-sfnt': _FontItem["default"],
'application/font-woff': _FontItem["default"],
'application/vnd.ms-opentype': _FontItem["default"],
'application/x-font-ttf': _FontItem["default"],
'application/x-font-truetype': _FontItem["default"],
'application/x-font-opentype': _FontItem["default"],
'font/opentype': _FontItem["default"],
'font/otf': _FontItem["default"],
'font/woff2': _FontItem["default"],
'application/x-dtbncx+xml': _NcxItem["default"],
'application/xhtml+xml': _SpineItem["default"],
'text/css': _CssItem["default"],
'image/gif': _ImageItem["default"],
'image/jpeg': _ImageItem["default"],
'image/png': _ImageItem["default"],
'image/bmp': _ImageItem["default"],
'image/svg+xml': _SvgItem["default"]
};
var type = types[mediaType.toLowerCase()];
return (0, _parserCore.isExists)(type) ? type : _DeadItem["default"];
}
}]);
return EpubParser;
}(_parserCore.Parser);
var _default = EpubParser;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

24

lib/index.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {

@@ -10,3 +8,3 @@ value: true

enumerable: true,
get: function get() {
get: function () {
return _parserCore.CryptoProvider;

@@ -17,3 +15,3 @@ }

enumerable: true,
get: function get() {
get: function () {
return _parserCore.AesCryptor;

@@ -24,3 +22,3 @@ }

enumerable: true,
get: function get() {
get: function () {
return _parserCore.Hash;

@@ -31,3 +29,3 @@ }

enumerable: true,
get: function get() {
get: function () {
return _parserCore.Errors;

@@ -38,3 +36,3 @@ }

enumerable: true,
get: function get() {
get: function () {
return _parserCore.LogLevel;

@@ -45,4 +43,4 @@ }

enumerable: true,
get: function get() {
return _EpubParser["default"];
get: function () {
return _EpubParser.default;
}

@@ -52,4 +50,4 @@ });

enumerable: true,
get: function get() {
return _EpubBook["default"];
get: function () {
return _EpubBook.default;
}

@@ -62,2 +60,4 @@ });

var _EpubBook = _interopRequireDefault(require("./model/EpubBook"));
var _EpubBook = _interopRequireDefault(require("./model/EpubBook"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

75

lib/loader/cssLoader.js
"use strict";
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = cssLoader;
exports.default = cssLoader;
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _parserCore = require("@ridi/parser-core");

@@ -18,3 +12,7 @@

var Types = {
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
const Types = {
SELECTOR_LIST: 'SelectorList',

@@ -32,3 +30,5 @@ TYPE_SELECTOR: 'TypeSelector',

if ((0, _parserCore.isExists)(namespace)) {
var extractBody = options.extractBody;
const {
extractBody
} = options;

@@ -52,17 +52,21 @@ if (extractBody === true) {

var namespace = cssItem.namespace;
var unwrappingTagList = getUnwrappingTagList(namespace, options);
const {
namespace
} = cssItem;
const unwrappingTagList = getUnwrappingTagList(namespace, options);
selectorList.children.each(function (selector, item, list) {
var shouldRemove = false;
var shouldUnwrap = false;
let shouldRemove = false;
let shouldUnwrap = false;
_cssTree["default"].walk(selector, function (node) {
var context = this;
_cssTree.default.walk(selector, function (node) {
const context = this;
if (!(0, _parserCore.isExists)(context.selector) || context.selector === selectorList) {
var name = node.name,
type = node.type;
const {
name,
type
} = node;
if (type === Types.SELECTOR_LIST) {
if ((0, _parserCore.isExists)(context["function"]) && context["function"].name.toLowerCase() !== 'not') {
if ((0, _parserCore.isExists)(context.function) && context.function.name.toLowerCase() !== 'not') {
if (handleRulePrelude(node, options, cssItem)) {

@@ -93,3 +97,3 @@ shouldRemove = true;

} else if ((0, _parserCore.isExists)(namespace)) {
var namespaceData = {
const namespaceData = {
type: Types.CLASS_SELECTOR,

@@ -100,7 +104,6 @@ name: namespace

if (shouldUnwrap) {
var array = selector.children.toArray();
const array = selector.children.toArray();
if (array.length > 1) {
var _array = (0, _slicedToArray2["default"])(array, 1),
head = _array[0];
const [head] = array;

@@ -129,9 +132,9 @@ if ((0, _parserCore.stringContains)(unwrappingTagList, head.name)) {

function handleRuleBlock(declarationList, options, cssItem) {
declarationList.children.each(function (declaration) {
var oldItem;
var newItem;
declarationList.children.each(declaration => {
let oldItem;
let newItem;
_cssTree["default"].walk(declaration, function (node, item) {
_cssTree.default.walk(declaration, (node, item) => {
if (node.type === Types.URL && (0, _parserCore.stringContains)([Types.STRING, Types.RAW], node.value.type)) {
var url = node.value.value.replace(/['"]/g, '');
let url = node.value.value.replace(/['"]/g, '');

@@ -145,3 +148,3 @@ if ((0, _parserCore.isExists)(options.basePath) && !(0, _parserCore.isUrl)(url)) {

type: Types.STRING,
value: "'".concat(url, "'")
value: `'${url}'`
}

@@ -185,3 +188,3 @@ });

var handlers = {
const handlers = {
Atrule: handleAtrule,

@@ -191,11 +194,9 @@ Rule: handleRuleset

function cssLoader(cssItem, string) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
function cssLoader(cssItem, string, options = {}) {
const ast = _cssTree.default.parse(string);
var ast = _cssTree["default"].parse(string);
_cssTree.default.walk(ast, {
leave: function (node, item, list) {
const context = this;
_cssTree["default"].walk(ast, {
leave: function leave(node, item, list) {
var context = this;
if ((0, _parserCore.isExists)(handlers[node.type])) {

@@ -207,5 +208,5 @@ handlers[node.type].call(context, node, item, list, options, cssItem);

return _cssTree["default"].generate(ast);
return _cssTree.default.generate(ast);
}
module.exports = exports.default;

131

lib/loader/spineLoader.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = spineLoader;
exports.default = spineLoader;

@@ -22,3 +20,5 @@ var _parserCore = require("@ridi/parser-core");

var Types = {
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const Types = {
TEXT: 'text',

@@ -28,3 +28,3 @@ COMMENT: 'comment',

};
var Names = {
const Names = {
Attrs: {

@@ -46,31 +46,33 @@ HREF: 'href',

function formatAttributes(attributes, options) {
return attributes.reduce(function (attrs, attribute) {
var key = attribute.key,
value = attribute.value;
return attributes.reduce((attrs, attribute) => {
const {
key,
value
} = attribute;
if (value === null) {
return "".concat(attrs, " ").concat(key);
return `${attrs} ${key}`;
}
if (options.usingCssOptions && key === Names.Attrs.STYLE) {
var dummyItem = new _CssItem["default"]({
const dummyItem = new _CssItem.default({
href: ''
});
var text = (0, _cssLoader["default"])(dummyItem, "tmp{".concat(value, "}"), options);
return "".concat(attrs, " ").concat(key, "=\"").concat(text.substring(4, text.length - 1), "\"");
const text = (0, _cssLoader.default)(dummyItem, `tmp{${value}}`, options);
return `${attrs} ${key}="${text.substring(4, text.length - 1)}"`;
}
if (!(0, _parserCore.isUrl)(value) && [Names.Attrs.HREF, Names.Attrs.SRC].some(function (name) {
return key.endsWith(name);
})) {
var basePath = options.basePath,
serializedAnchor = options.serializedAnchor;
if (!(0, _parserCore.isUrl)(value) && [Names.Attrs.HREF, Names.Attrs.SRC].some(name => key.endsWith(name))) {
const {
basePath,
serializedAnchor
} = options;
if (serializedAnchor && key.endsWith(Names.Attrs.HREF)) {
var components = value.split('#');
const components = value.split('#');
var spineIndex = serializedAnchor[_path["default"].basename(components[0])];
const spineIndex = serializedAnchor[_path.default.basename(components[0])];
if ((0, _parserCore.isExists)(spineIndex)) {
return "".concat(attrs, " ").concat(key, "=\"").concat(spineIndex).concat(components[1] ? "#".concat(components[1]) : '', "\"");
return `${attrs} ${key}="${spineIndex}${components[1] ? `#${components[1]}` : ''}"`;
}

@@ -80,7 +82,7 @@ }

if ((0, _parserCore.isExists)(basePath) && value.split('#')[0].length > 0) {
return "".concat(attrs, " ").concat(key, "=\"").concat((0, _parserCore.safePathJoin)(basePath, value), "\"");
return `${attrs} ${key}="${(0, _parserCore.safePathJoin)(basePath, value)}"`;
}
}
return "".concat(attrs, " ").concat(key, "=\"").concat(value, "\"");
return `${attrs} ${key}="${value}"`;
}, '');

@@ -90,3 +92,3 @@ }

function stringify(ast, options) {
return ast.map(function (node) {
return ast.map(node => {
if (node.type === Types.TEXT) {

@@ -97,11 +99,13 @@ return node.content;

if (node.type === Types.COMMENT) {
return "<!--".concat(node.content, "-->");
return `<!--${node.content}-->`;
}
var tagName = node.tagName,
attributes = node.attributes,
children = node.children;
var ignored = options.ignoreScript && tagName === Names.Tags.SCRIPT;
var isSelfClosing = (0, _compat.arrayIncludes)(options.voidTags, tagName);
var innerHTML = '';
const {
tagName,
attributes,
children
} = node;
const ignored = options.ignoreScript && tagName === Names.Tags.SCRIPT;
const isSelfClosing = (0, _compat.arrayIncludes)(options.voidTags, tagName);
let innerHTML = '';

@@ -112,21 +116,21 @@ if (ignored) {

innerHTML += "<".concat(tagName).concat(formatAttributes(attributes, options));
innerHTML += "".concat(isSelfClosing && tagName !== Names.Tags.DOCTYPE ? '/>' : '>');
innerHTML += `<${tagName}${formatAttributes(attributes, options)}`;
innerHTML += `${isSelfClosing && tagName !== Names.Tags.DOCTYPE ? '/>' : '>'}`;
if (!isSelfClosing) {
if (options.usingCssOptions && tagName === Names.Tags.STYLE && children.length === 1) {
var dummyItem = new _CssItem["default"]({
const dummyItem = new _CssItem.default({
href: ''
});
var inlineStyle = children[0].content;
innerHTML += (0, _cssLoader["default"])(dummyItem, inlineStyle, options);
const inlineStyle = children[0].content;
innerHTML += (0, _cssLoader.default)(dummyItem, inlineStyle, options);
} else {
innerHTML += "".concat(stringify(children, options));
innerHTML += `${stringify(children, options)}`;
}
innerHTML += "</".concat(tagName, ">");
innerHTML += `</${tagName}>`;
}
if (ignored) {
innerHTML += " --><".concat(tagName, "></").concat(tagName, ">");
innerHTML += ` --><${tagName}></${tagName}>`;
}

@@ -139,7 +143,7 @@

function getSpineIndexMap(spineItem) {
var map = {};
var spine = spineItem;
const map = {};
let spine = spineItem;
do {
map[_path["default"].basename(spine.href)] = spine.index;
map[_path.default.basename(spine.href)] = spine.index;
spine = spine.next();

@@ -152,8 +156,6 @@ } while (spine);

function getStringifyOptions(spineItem, options) {
var additional = {
const additional = {
basePath: (0, _parserCore.isExists)(options.basePath) ? (0, _parserCore.safePathJoin)(options.basePath, (0, _parserCore.safeDirname)(spineItem.href)) : undefined,
serializedAnchor: options.serializedAnchor === true ? getSpineIndexMap(spineItem.first()) : false,
usingCssOptions: Object.keys(options).find(function (key) {
return key.startsWith('remove');
}) !== undefined
usingCssOptions: Object.keys(options).find(key => key.startsWith('remove')) !== undefined
};

@@ -164,6 +166,6 @@ return (0, _parserCore.mergeObjects)(_himalaya.parseDefaults, (0, _parserCore.mergeObjects)(options, additional));

function getSafeBody(ast) {
var BODY = Names.Tags.BODY;
var body = ast.find(function (child) {
return child.tagName === BODY;
});
const {
BODY
} = Names.Tags;
const body = ast.find(child => child.tagName === BODY);
if ((0, _parserCore.isExists)(body)) return body;

@@ -179,6 +181,6 @@ return {

function getSafeHtml(ast) {
var HTML = Names.Tags.HTML;
var html = ast.find(function (child) {
return child.tagName === HTML;
});
const {
HTML
} = Names.Tags;
const html = ast.find(child => child.tagName === HTML);
if ((0, _parserCore.isExists)(html)) return html;

@@ -193,11 +195,10 @@ return {

function spineLoader(spineItem, string) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var ast = (0, _himalaya.parse)(string);
var stringifyOptions = getStringifyOptions(spineItem, options);
function spineLoader(spineItem, string, options = {}) {
const ast = (0, _himalaya.parse)(string);
const stringifyOptions = getStringifyOptions(spineItem, options);
if (stringifyOptions.extractBody) {
var html = getSafeHtml(ast);
var body = getSafeBody(html.children);
var attrs = body.attributes;
const html = getSafeHtml(ast);
const body = getSafeBody(html.children);
let attrs = body.attributes;

@@ -207,9 +208,7 @@ if ((0, _parserCore.isExists)(spineItem.styles)) {

key: 'class',
value: spineItem.styles.map(function (style) {
return "".concat(style.namespace);
}).join(' ').trim()
value: spineItem.styles.map(style => `${style.namespace}`).join(' ').trim()
}]);
}
var innerHTML = stringify(body.children, stringifyOptions);
const innerHTML = stringify(body.children, stringifyOptions);

@@ -220,5 +219,3 @@ if ((0, _parserCore.isFunc)(options.extractBody)) {

return "<body ".concat(attrs.map(function (attr) {
return "".concat(attr.key, "=\"").concat(attr.value, "\"");
}).join(' '), ">").concat(innerHTML, "</body>");
return `<body ${attrs.map(attr => `${attr.key}="${attr.value}"`).join(' ')}>${innerHTML}</body>`;
}

@@ -225,0 +222,0 @@

44

lib/loader/xmlLoader.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = xmlLoader;
exports.default = xmlLoader;
exports.textNodeName = exports.getValues = exports.getValue = void 0;

@@ -17,3 +15,5 @@

var normalizeKey = function normalizeKey(obj, keyTranslator) {
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const normalizeKey = (obj, keyTranslator) => {
if ((0, _parserCore.isString)(obj)) {

@@ -23,6 +23,6 @@ return obj;

var newObj = {};
Object.keys(obj).forEach(function (oldKey) {
var newKey = (0, _parserCore.isExists)(keyTranslator) ? keyTranslator(oldKey) : oldKey;
var value = obj[oldKey];
const newObj = {};
Object.keys(obj).forEach(oldKey => {
const newKey = (0, _parserCore.isExists)(keyTranslator) ? keyTranslator(oldKey) : oldKey;
let value = obj[oldKey];

@@ -44,3 +44,3 @@ if ((0, _parserCore.isArray)(value)) {

var getValue = function getValue(any, keyTranslator) {
const getValue = (any, keyTranslator) => {
if (!(0, _parserCore.isExists)(any)) {

@@ -51,3 +51,3 @@ return undefined;

if ((0, _parserCore.isArray)(any)) {
var first = any[0];
const first = any[0];

@@ -66,3 +66,3 @@ if (!(0, _parserCore.isExists)(first)) {

var getValues = function getValues(any, keyTranslator) {
const getValues = (any, keyTranslator) => {
if (!(0, _parserCore.isExists)(any)) {

@@ -72,14 +72,12 @@ return [];

return (0, _parserCore.isArray)(any) ? any.map(function (item) {
return normalizeKey(item, keyTranslator);
}) : [normalizeKey(any, keyTranslator)];
return (0, _parserCore.isArray)(any) ? any.map(item => normalizeKey(item, keyTranslator)) : [normalizeKey(any, keyTranslator)];
};
exports.getValues = getValues;
var textNodeName = '#text';
const textNodeName = '#text';
exports.textNodeName = textNodeName;
function xmlLoader(string) {
return _fastXmlParser["default"].parse(string, {
textNodeName: textNodeName,
return _fastXmlParser.default.parse(string, {
textNodeName,
attributeNamePrefix: '',

@@ -95,11 +93,7 @@ attrNodeName: false,

parseTrueNumberOnly: true,
tagValueProcessor: function tagValueProcessor(value) {
return _he["default"].decode(value);
},
attrValueProcessor: function attrValueProcessor(value) {
return _he["default"].decode(value, {
isAttributeValue: true
});
}
tagValueProcessor: value => _he.default.decode(value),
attrValueProcessor: value => _he.default.decode(value, {
isAttributeValue: true
})
});
}

51

lib/model/Author.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _parserCore = require("@ridi/parser-core");
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");
var Roles = Object.freeze({
const Roles = Object.freeze({
UNDEFINED: 'undefined',

@@ -52,10 +46,10 @@ UNKNOWN: 'unknown',

var Author = function () {
function Author() {
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
(0, _classCallCheck2["default"])(this, Author);
(0, _defineProperty2["default"])(this, "name", void 0);
(0, _defineProperty2["default"])(this, "fileAs", void 0);
(0, _defineProperty2["default"])(this, "role", void 0);
class Author {
constructor(rawObj = {}) {
_defineProperty(this, "name", void 0);
_defineProperty(this, "fileAs", void 0);
_defineProperty(this, "role", void 0);
if ((0, _parserCore.isString)(rawObj)) {

@@ -82,18 +76,15 @@ this.name = rawObj;

(0, _createClass2["default"])(Author, [{
key: "toRaw",
value: function toRaw() {
return {
name: this.name,
fileAs: this.fileAs,
role: this.role
};
}
}]);
return Author;
}();
toRaw() {
return {
name: this.name,
fileAs: this.fileAs,
role: this.role
};
}
}
Author.Roles = Roles;
var _default = Author;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

94

lib/model/BaseEpubItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _parserCore = require("@ridi/parser-core");
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
class BaseEpubItem extends _parserCore.BaseItem {
get isFileExists() {
return this.size !== undefined;
}
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
get defaultEncoding() {
return undefined;
}
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
constructor(rawObj = {}, freeze = true) {
super(rawObj);
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
_defineProperty(this, "id", void 0);
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
_defineProperty(this, "href", void 0);
var _parserCore = require("@ridi/parser-core");
_defineProperty(this, "mediaType", void 0);
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
this.id = rawObj.id;
this.href = rawObj.href;
this.mediaType = rawObj.mediaType;
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
var BaseEpubItem = function (_BaseItem) {
(0, _inherits2["default"])(BaseEpubItem, _BaseItem);
var _super = _createSuper(BaseEpubItem);
(0, _createClass2["default"])(BaseEpubItem, [{
key: "isFileExists",
get: function get() {
return this.size !== undefined;
if (freeze && this.constructor === BaseEpubItem) {
Object.freeze(this);
}
}, {
key: "defaultEncoding",
get: function get() {
return undefined;
}
}]);
}
function BaseEpubItem() {
var _this;
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, BaseEpubItem);
_this = _super.call(this, rawObj);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "id", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "href", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "mediaType", void 0);
_this.id = rawObj.id;
_this.href = rawObj.href;
_this.mediaType = rawObj.mediaType;
if (freeze && _this.constructor === BaseEpubItem) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
}
return _this;
toRaw() {
return {
id: this.id,
href: this.href,
mediaType: this.mediaType,
size: this.size,
itemType: 'Item'
};
}
(0, _createClass2["default"])(BaseEpubItem, [{
key: "toRaw",
value: function toRaw() {
return {
id: this.id,
href: this.href,
mediaType: this.mediaType,
size: this.size,
itemType: 'Item'
};
}
}]);
return BaseEpubItem;
}(_parserCore.BaseItem);
}
var _default = BaseEpubItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

78

lib/model/CssItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");
var _BaseEpubItem2 = _interopRequireDefault(require("./BaseEpubItem"));
var _BaseEpubItem = _interopRequireDefault(require("./BaseEpubItem"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var CssItem = function (_BaseEpubItem) {
(0, _inherits2["default"])(CssItem, _BaseEpubItem);
class CssItem extends _BaseEpubItem.default {
get defaultEncoding() {
return 'utf8';
}
var _super = _createSuper(CssItem);
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
(0, _createClass2["default"])(CssItem, [{
key: "defaultEncoding",
get: function get() {
return 'utf8';
}
}]);
_defineProperty(this, "namespace", void 0);
function CssItem() {
var _this;
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, CssItem);
_this = _super.call(this, rawObj, freeze);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "namespace", void 0);
if ((0, _parserCore.isExists)(rawObj.namespace)) {
_this.namespace = rawObj.namespace;
this.namespace = rawObj.namespace;
}
if (freeze && _this.constructor === CssItem) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
if (freeze && this.constructor === CssItem) {
Object.freeze(this);
}
}
return _this;
toRaw() {
return (0, _parserCore.mergeObjects)(super.toRaw(), {
namespace: this.namespace,
itemType: 'CssItem'
});
}
(0, _createClass2["default"])(CssItem, [{
key: "toRaw",
value: function toRaw() {
return (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(CssItem.prototype), "toRaw", this).call(this), {
namespace: this.namespace,
itemType: 'CssItem'
});
}
}]);
return CssItem;
}(_BaseEpubItem2["default"]);
}
var _default = CssItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

46

lib/model/DateTime.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _parserCore = require("@ridi/parser-core");
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");
var Events = Object.freeze({
const Events = Object.freeze({
UNDEFINED: 'undefined',

@@ -26,9 +20,8 @@ UNKNOWN: 'unknown',

var DateTime = function () {
function DateTime() {
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
(0, _classCallCheck2["default"])(this, DateTime);
(0, _defineProperty2["default"])(this, "value", void 0);
(0, _defineProperty2["default"])(this, "event", void 0);
class DateTime {
constructor(rawObj = {}) {
_defineProperty(this, "value", void 0);
_defineProperty(this, "event", void 0);
if ((0, _parserCore.isString)(rawObj)) {

@@ -53,17 +46,14 @@ this.value = rawObj;

(0, _createClass2["default"])(DateTime, [{
key: "toRaw",
value: function toRaw() {
return {
value: this.value,
event: this.event
};
}
}]);
return DateTime;
}();
toRaw() {
return {
value: this.value,
event: this.event
};
}
}
DateTime.Events = Events;
var _default = DateTime;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

74

lib/model/DeadItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");
var _BaseEpubItem2 = _interopRequireDefault(require("./BaseEpubItem"));
var _BaseEpubItem = _interopRequireDefault(require("./BaseEpubItem"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Reason = Object.freeze({
const Reason = Object.freeze({
UNDEFINED: 'undefined',

@@ -43,49 +25,37 @@ UNKNOWN: 'unknown',

var DeadItem = function (_BaseEpubItem) {
(0, _inherits2["default"])(DeadItem, _BaseEpubItem);
class DeadItem extends _BaseEpubItem.default {
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
var _super = _createSuper(DeadItem);
_defineProperty(this, "reason", void 0);
function DeadItem() {
var _this;
_defineProperty(this, "itemType", void 0);
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, DeadItem);
_this = _super.call(this, rawObj, freeze);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "reason", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "itemType", void 0);
if ((0, _parserCore.isExists)(rawObj.reason)) {
if ((0, _parserCore.stringContains)(Object.values(Reason), rawObj.reason)) {
_this.reason = rawObj.reason.toLowerCase();
this.reason = rawObj.reason.toLowerCase();
} else {
_this.reason = Reason.UNKNOWN;
this.reason = Reason.UNKNOWN;
}
} else {
_this.reason = Reason.UNDEFINED;
this.reason = Reason.UNDEFINED;
}
if (freeze) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
Object.freeze(this);
}
}
return _this;
toRaw() {
return (0, _parserCore.mergeObjects)(super.toRaw(), {
reason: this.reason,
itemType: 'DeadItem'
});
}
(0, _createClass2["default"])(DeadItem, [{
key: "toRaw",
value: function toRaw() {
return (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(DeadItem.prototype), "toRaw", this).call(this), {
reason: this.reason,
itemType: 'DeadItem'
});
}
}]);
return DeadItem;
}(_BaseEpubItem2["default"]);
}
DeadItem.Reason = Reason;
var _default = DeadItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

339

lib/model/EpubBook.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");

@@ -52,34 +36,20 @@

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function postSpines(spines, styles) {
var firstSpine = spines[0];
spines.sort(function (s1, s2) {
return s1.index - s2.index;
}).forEach(function (spine, idx, list) {
var prevSpine = list[idx - 1];
var nextSpine = list[idx + 1];
const firstSpine = spines[0];
spines.sort((s1, s2) => s1.index - s2.index).forEach((spine, idx, list) => {
const prevSpine = list[idx - 1];
const nextSpine = list[idx + 1];
spine.prev = function () {
return prevSpine;
};
spine.prev = () => prevSpine;
spine.next = function () {
return nextSpine;
};
spine.next = () => nextSpine;
spine.first = function () {
return firstSpine;
};
spine.first = () => firstSpine;
if ((0, _parserCore.isExists)(spine.styles)) {
spine.styles = spine.styles.map(function (href) {
return styles.find(function (style) {
return style.href === href;
});
}).filter(function (style) {
return (0, _parserCore.isExists)(style);
});
spine.styles = spine.styles.map(href => styles.find(style => style.href === href)).filter(style => (0, _parserCore.isExists)(style));
}

@@ -93,16 +63,12 @@

if ((0, _parserCore.isExists)(ncx)) {
var spineMapping = function spineMapping(navPoint) {
navPoint.spine = spines.find(function (spine) {
var href = navPoint.src.replace("#".concat(navPoint.anchor || ''), '');
const spineMapping = navPoint => {
navPoint.spine = spines.find(spine => {
const href = navPoint.src.replace(`#${navPoint.anchor || ''}`, '');
return spine.href === href;
});
navPoint.children.forEach(function (child) {
return spineMapping(child);
});
navPoint.children.forEach(child => spineMapping(child));
Object.freeze(navPoint);
};
ncx.navPoints.forEach(function (navPoint) {
return spineMapping(navPoint);
});
ncx.navPoints.forEach(navPoint => spineMapping(navPoint));
Object.freeze(ncx);

@@ -113,6 +79,4 @@ }

function postGuides(guides, spines) {
guides.forEach(function (guide) {
guide.item = spines.find(function (spine) {
return spine.href === guide.href;
});
guides.forEach(guide => {
guide.item = spines.find(spine => spine.href === guide.href);
Object.freeze(guide);

@@ -125,94 +89,105 @@ });

case 'Item':
return _BaseEpubItem["default"];
return _BaseEpubItem.default;
case 'SpineItem':
return _SpineItem["default"];
return _SpineItem.default;
case 'NcxItem':
return _NcxItem["default"];
return _NcxItem.default;
case 'FontItem':
return _FontItem["default"];
return _FontItem.default;
case 'ImageItem':
return _ImageItem["default"];
return _ImageItem.default;
case 'CssItem':
return _CssItem["default"];
return _CssItem.default;
case 'InlineCssItem':
return _InlineCssItem["default"];
return _InlineCssItem.default;
default:
return _DeadItem["default"];
return _DeadItem.default;
}
}
var EpubBook = function (_BaseBook) {
(0, _inherits2["default"])(EpubBook, _BaseBook);
class EpubBook extends _parserCore.BaseBook {
constructor(rawBook = {}) {
super();
var _super = _createSuper(EpubBook);
_defineProperty(this, "titles", void 0);
function EpubBook() {
var _this;
_defineProperty(this, "creators", void 0);
var rawBook = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
(0, _classCallCheck2["default"])(this, EpubBook);
_this = _super.call(this);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "titles", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "creators", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "subjects", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "description", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "publisher", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "contributors", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "dates", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "type", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "format", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "identifiers", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "source", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "languages", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "relation", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "coverage", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "rights", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "version", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "metas", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "items", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "spines", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "ncx", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "fonts", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "cover", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "images", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "styles", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "guides", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "deadItems", void 0);
_this.titles = rawBook.titles || [];
_this.creators = (rawBook.creators || []).map(function (rawObj) {
return new _Author["default"](rawObj);
});
_this.subjects = rawBook.subjects || [];
_this.description = rawBook.description;
_this.publisher = rawBook.publisher;
_this.contributors = (rawBook.contributors || []).map(function (rawObj) {
return new _Author["default"](rawObj);
});
_this.dates = (rawBook.dates || []).map(function (rawObj) {
return new _DateTime["default"](rawObj);
});
_this.type = rawBook.type;
_this.format = rawBook.format;
_this.identifiers = (rawBook.identifiers || []).map(function (rawObj) {
return new _Identifier["default"](rawObj);
});
_this.source = rawBook.source;
_this.languages = rawBook.languages || [];
_this.relation = rawBook.relation;
_this.coverage = rawBook.coverage;
_this.rights = rawBook.rights;
_this.version = new _parserCore.Version(rawBook.version);
_this.metas = (rawBook.metas || []).map(function (rawObj) {
return new _Meta["default"](rawObj);
});
_this.items = (rawBook.items || []).map(function (rawObj) {
var itemType = rawObj.itemType;
_defineProperty(this, "subjects", void 0);
_defineProperty(this, "description", void 0);
_defineProperty(this, "publisher", void 0);
_defineProperty(this, "contributors", void 0);
_defineProperty(this, "dates", void 0);
_defineProperty(this, "type", void 0);
_defineProperty(this, "format", void 0);
_defineProperty(this, "identifiers", void 0);
_defineProperty(this, "source", void 0);
_defineProperty(this, "languages", void 0);
_defineProperty(this, "relation", void 0);
_defineProperty(this, "coverage", void 0);
_defineProperty(this, "rights", void 0);
_defineProperty(this, "version", void 0);
_defineProperty(this, "metas", void 0);
_defineProperty(this, "items", void 0);
_defineProperty(this, "spines", void 0);
_defineProperty(this, "ncx", void 0);
_defineProperty(this, "fonts", void 0);
_defineProperty(this, "cover", void 0);
_defineProperty(this, "images", void 0);
_defineProperty(this, "styles", void 0);
_defineProperty(this, "guides", void 0);
_defineProperty(this, "deadItems", void 0);
this.titles = rawBook.titles || [];
this.creators = (rawBook.creators || []).map(rawObj => new _Author.default(rawObj));
this.subjects = rawBook.subjects || [];
this.description = rawBook.description;
this.publisher = rawBook.publisher;
this.contributors = (rawBook.contributors || []).map(rawObj => new _Author.default(rawObj));
this.dates = (rawBook.dates || []).map(rawObj => new _DateTime.default(rawObj));
this.type = rawBook.type;
this.format = rawBook.format;
this.identifiers = (rawBook.identifiers || []).map(rawObj => new _Identifier.default(rawObj));
this.source = rawBook.source;
this.languages = rawBook.languages || [];
this.relation = rawBook.relation;
this.coverage = rawBook.coverage;
this.rights = rawBook.rights;
this.version = new _parserCore.Version(rawBook.version);
this.metas = (rawBook.metas || []).map(rawObj => new _Meta.default(rawObj));
this.items = (rawBook.items || []).map(rawObj => {
let {
itemType
} = rawObj;
if ((0, _parserCore.isString)(itemType)) {

@@ -222,83 +197,47 @@ itemType = getItemTypeFromString(itemType);

var freeze = !(itemType === _SpineItem["default"] || itemType === _NcxItem["default"]);
const freeze = !(itemType === _SpineItem.default || itemType === _NcxItem.default);
return new itemType(rawObj, freeze);
});
_this.spines = _this.items.filter(function (item) {
return item instanceof _SpineItem["default"];
}).sort(function (lhs, rhs) {
return lhs.index - rhs.index;
});
_this.ncx = _this.items.find(function (item) {
return item instanceof _NcxItem["default"];
});
_this.fonts = _this.items.filter(function (item) {
return item instanceof _FontItem["default"];
});
_this.cover = _this.items.find(function (item) {
return item.isCover;
});
_this.images = _this.items.filter(function (item) {
return item instanceof _ImageItem["default"];
});
_this.styles = _this.items.filter(function (item) {
return item instanceof _CssItem["default"];
});
_this.guides = (rawBook.guides || []).map(function (rawObj) {
return new _Guide["default"](rawObj, false);
});
_this.deadItems = _this.items.filter(function (item) {
return item instanceof _DeadItem["default"];
});
postSpines(_this.spines, _this.styles);
postNcx(_this.ncx, _this.spines);
postGuides(_this.guides, _this.spines);
Object.freeze((0, _assertThisInitialized2["default"])(_this));
return _this;
this.spines = this.items.filter(item => item instanceof _SpineItem.default).sort((lhs, rhs) => lhs.index - rhs.index);
this.ncx = this.items.find(item => item instanceof _NcxItem.default);
this.fonts = this.items.filter(item => item instanceof _FontItem.default);
this.cover = this.items.find(item => item.isCover);
this.images = this.items.filter(item => item instanceof _ImageItem.default);
this.styles = this.items.filter(item => item instanceof _CssItem.default);
this.guides = (rawBook.guides || []).map(rawObj => new _Guide.default(rawObj, false));
this.deadItems = this.items.filter(item => item instanceof _DeadItem.default);
postSpines(this.spines, this.styles);
postNcx(this.ncx, this.spines);
postGuides(this.guides, this.spines);
Object.freeze(this);
}
(0, _createClass2["default"])(EpubBook, [{
key: "toRaw",
value: function toRaw() {
return {
titles: this.titles,
creators: this.creators.map(function (creator) {
return creator.toRaw();
}),
subjects: this.subjects,
description: this.description,
publisher: this.publisher,
contributors: this.contributors.map(function (contributor) {
return contributor.toRaw();
}),
dates: this.dates.map(function (date) {
return date.toRaw();
}),
type: this.type,
format: this.format,
identifiers: this.identifiers.map(function (identifier) {
return identifier.toRaw();
}),
source: this.source,
languages: this.languages,
relation: this.relation,
coverage: this.coverage,
rights: this.rights,
version: this.version.toString(),
metas: this.metas.map(function (meta) {
return meta.toRaw();
}),
items: this.items.map(function (item) {
return item.toRaw();
}),
guides: this.guides.map(function (guide) {
return guide.toRaw();
})
};
}
}]);
return EpubBook;
}(_parserCore.BaseBook);
toRaw() {
return {
titles: this.titles,
creators: this.creators.map(creator => creator.toRaw()),
subjects: this.subjects,
description: this.description,
publisher: this.publisher,
contributors: this.contributors.map(contributor => contributor.toRaw()),
dates: this.dates.map(date => date.toRaw()),
type: this.type,
format: this.format,
identifiers: this.identifiers.map(identifier => identifier.toRaw()),
source: this.source,
languages: this.languages,
relation: this.relation,
coverage: this.coverage,
rights: this.rights,
version: this.version.toString(),
metas: this.metas.map(meta => meta.toRaw()),
items: this.items.map(item => item.toRaw()),
guides: this.guides.map(guide => guide.toRaw())
};
}
}
var _default = EpubBook;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

58

lib/model/EpubParseContext.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _parserCore = require("@ridi/parser-core");
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _EpubBook = _interopRequireDefault(require("./EpubBook"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
class EpubParseContext extends _parserCore.BaseParseContext {
constructor() {
super();
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
_defineProperty(this, "rawBook", void 0);
var _parserCore = require("@ridi/parser-core");
_defineProperty(this, "opfPath", void 0);
var _EpubBook = _interopRequireDefault(require("./EpubBook"));
_defineProperty(this, "basePath", void 0);
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
_defineProperty(this, "foundCover", void 0);
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
var EpubParseContext = function (_BaseParseContext) {
(0, _inherits2["default"])(EpubParseContext, _BaseParseContext);
var _super = _createSuper(EpubParseContext);
function EpubParseContext() {
var _this;
(0, _classCallCheck2["default"])(this, EpubParseContext);
_this = _super.call(this);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "rawBook", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "opfPath", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "basePath", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "foundCover", void 0);
var rawBook = {};
Object.keys(new _EpubBook["default"]()).forEach(function (key) {
const rawBook = {};
Object.keys(new _EpubBook.default()).forEach(key => {
rawBook[key] = undefined;
});
_this.rawBook = rawBook;
_this.opfPath = undefined;
_this.basePath = undefined;
_this.foundCover = false;
return _this;
this.rawBook = rawBook;
this.opfPath = undefined;
this.basePath = undefined;
this.foundCover = false;
}
return EpubParseContext;
}(_parserCore.BaseParseContext);
}
var _default = EpubParseContext;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

31

lib/model/EpubReadContext.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _parserCore = require("@ridi/parser-core");
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
class ReadContext extends _parserCore.BaseReadContext {}
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
var ReadContext = function (_BaseReadContext) {
(0, _inherits2["default"])(ReadContext, _BaseReadContext);
var _super = _createSuper(ReadContext);
function ReadContext() {
(0, _classCallCheck2["default"])(this, ReadContext);
return _super.apply(this, arguments);
}
return ReadContext;
}(_parserCore.BaseReadContext);
var _default = ReadContext;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

60

lib/model/FontItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _parserCore = require("@ridi/parser-core");
var _BaseEpubItem2 = _interopRequireDefault(require("./BaseEpubItem"));
var _BaseEpubItem = _interopRequireDefault(require("./BaseEpubItem"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
class FontItem extends _BaseEpubItem.default {
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
var FontItem = function (_BaseEpubItem) {
(0, _inherits2["default"])(FontItem, _BaseEpubItem);
var _super = _createSuper(FontItem);
function FontItem() {
var _this;
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, FontItem);
_this = _super.call(this, rawObj, freeze);
if (freeze) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
Object.freeze(this);
}
}
return _this;
toRaw() {
return (0, _parserCore.mergeObjects)(super.toRaw(), {
itemType: 'FontItem'
});
}
(0, _createClass2["default"])(FontItem, [{
key: "toRaw",
value: function toRaw() {
return (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(FontItem.prototype), "toRaw", this).call(this), {
itemType: 'FontItem'
});
}
}]);
return FontItem;
}(_BaseEpubItem2["default"]);
}
var _default = FontItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

40

lib/model/Guide.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _parserCore = require("@ridi/parser-core");
var Types = Object.freeze({
const Types = Object.freeze({
UNDEFINED: 'undefined',

@@ -38,7 +32,4 @@ UNKNOWN: 'unknown',

var Guide = function () {
function Guide() {
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, Guide);
class Guide {
constructor(rawObj = {}, freeze = true) {
this.title = rawObj.title;

@@ -64,18 +55,15 @@

(0, _createClass2["default"])(Guide, [{
key: "toRaw",
value: function toRaw() {
return {
title: this.title,
type: this.type,
href: this.href
};
}
}]);
return Guide;
}();
toRaw() {
return {
title: this.title,
type: this.type,
href: this.href
};
}
}
Guide.Types = Types;
var _default = Guide;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

38

lib/model/Identifier.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _parserCore = require("@ridi/parser-core");
var Schemes = Object.freeze({
const Schemes = Object.freeze({
UNDEFINED: 'undefined',

@@ -28,7 +22,4 @@ UNKNOWN: 'unknown',

var Identifier = function () {
function Identifier() {
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
(0, _classCallCheck2["default"])(this, Identifier);
class Identifier {
constructor(rawObj = {}) {
if ((0, _parserCore.isString)(rawObj)) {

@@ -53,17 +44,14 @@ this.value = rawObj;

(0, _createClass2["default"])(Identifier, [{
key: "toRaw",
value: function toRaw() {
return {
value: this.value,
scheme: this.scheme
};
}
}]);
return Identifier;
}();
toRaw() {
return {
value: this.value,
scheme: this.scheme
};
}
}
Identifier.Schemes = Schemes;
var _default = Identifier;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

68

lib/model/ImageItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");
var _BaseEpubItem2 = _interopRequireDefault(require("./BaseEpubItem"));
var _BaseEpubItem = _interopRequireDefault(require("./BaseEpubItem"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var ImageItem = function (_BaseEpubItem) {
(0, _inherits2["default"])(ImageItem, _BaseEpubItem);
class ImageItem extends _BaseEpubItem.default {
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
var _super = _createSuper(ImageItem);
_defineProperty(this, "isCover", void 0);
function ImageItem() {
var _this;
this.isCover = rawObj.isCover || false;
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, ImageItem);
_this = _super.call(this, rawObj, freeze);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "isCover", void 0);
_this.isCover = rawObj.isCover || false;
if (freeze && _this.constructor === ImageItem) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
if (freeze && this.constructor === ImageItem) {
Object.freeze(this);
}
}
return _this;
toRaw() {
return (0, _parserCore.mergeObjects)(super.toRaw(), {
isCover: this.isCover,
itemType: 'ImageItem'
});
}
(0, _createClass2["default"])(ImageItem, [{
key: "toRaw",
value: function toRaw() {
return (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(ImageItem.prototype), "toRaw", this).call(this), {
isCover: this.isCover,
itemType: 'ImageItem'
});
}
}]);
return ImageItem;
}(_BaseEpubItem2["default"]);
}
var _default = ImageItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

66

lib/model/InlineCssItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");
var _CssItem2 = _interopRequireDefault(require("./CssItem"));
var _CssItem = _interopRequireDefault(require("./CssItem"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var InlineCssItem = function (_CssItem) {
(0, _inherits2["default"])(InlineCssItem, _CssItem);
class InlineCssItem extends _CssItem.default {
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
var _super = _createSuper(InlineCssItem);
_defineProperty(this, "style", void 0);
function InlineCssItem() {
var _this;
this.style = rawObj.style || '';
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, InlineCssItem);
_this = _super.call(this, rawObj, freeze);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "style", void 0);
_this.style = rawObj.style || '';
if (freeze) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
Object.freeze(this);
}
}
return _this;
toRaw() {
return (0, _parserCore.mergeObjects)(super.toRaw(), {
style: this.style,
itemType: 'InlineCssItem'
});
}
(0, _createClass2["default"])(InlineCssItem, [{
key: "toRaw",
value: function toRaw() {
return (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(InlineCssItem.prototype), "toRaw", this).call(this), {
style: this.style,
itemType: 'InlineCssItem'
});
}
}]);
return InlineCssItem;
}(_CssItem2["default"]);
}
var _default = InlineCssItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

39

lib/model/Meta.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
class Meta {
constructor(rawObj = {}) {
_defineProperty(this, "name", void 0);
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
_defineProperty(this, "content", void 0);
var Meta = function () {
function Meta() {
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
(0, _classCallCheck2["default"])(this, Meta);
(0, _defineProperty2["default"])(this, "name", void 0);
(0, _defineProperty2["default"])(this, "content", void 0);
this.name = rawObj.name;

@@ -27,16 +21,13 @@ this.content = rawObj.content;

(0, _createClass2["default"])(Meta, [{
key: "toRaw",
value: function toRaw() {
return {
name: this.name,
content: this.content
};
}
}]);
return Meta;
}();
toRaw() {
return {
name: this.name,
content: this.content
};
}
}
var _default = Meta;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

80

lib/model/NavPoint.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _parserCore = require("@ridi/parser-core");
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
class NavPoint {
constructor(rawObj = {}, freeze = true) {
_defineProperty(this, "id", void 0);
var _parserCore = require("@ridi/parser-core");
_defineProperty(this, "label", void 0);
var NavPoint = function () {
function NavPoint() {
var _this = this;
_defineProperty(this, "src", void 0);
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, NavPoint);
(0, _defineProperty2["default"])(this, "id", void 0);
(0, _defineProperty2["default"])(this, "label", void 0);
(0, _defineProperty2["default"])(this, "src", void 0);
(0, _defineProperty2["default"])(this, "anchor", void 0);
(0, _defineProperty2["default"])(this, "depth", void 0);
(0, _defineProperty2["default"])(this, "children", void 0);
(0, _defineProperty2["default"])(this, "spine", void 0);
_defineProperty(this, "anchor", void 0);
_defineProperty(this, "depth", void 0);
_defineProperty(this, "children", void 0);
_defineProperty(this, "spine", void 0);
this.id = rawObj.id;

@@ -36,11 +32,8 @@ this.label = (rawObj.navLabel || {}).text;

this.anchor = function () {
var src = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
return src.split('#')[1];
}(this.src);
this.anchor = ((src = '') => src.split('#')[1])(this.src);
this.depth = rawObj.depth || 0;
this.children = (rawObj.children || []).map(function (child) {
this.children = (rawObj.children || []).map(child => {
return new NavPoint((0, _parserCore.mergeObjects)(child, {
depth: _this.depth + 1
depth: this.depth + 1
}), freeze);

@@ -55,24 +48,19 @@ });

(0, _createClass2["default"])(NavPoint, [{
key: "toRaw",
value: function toRaw() {
return {
id: this.id,
navLabel: {
text: this.label
},
content: {
src: this.src
},
children: this.children.map(function (child) {
return child.toRaw();
})
};
}
}]);
return NavPoint;
}();
toRaw() {
return {
id: this.id,
navLabel: {
text: this.label
},
content: {
src: this.src
},
children: this.children.map(child => child.toRaw())
};
}
}
var _default = NavPoint;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

79

lib/model/NcxItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _parserCore = require("@ridi/parser-core");
var _BaseEpubItem2 = _interopRequireDefault(require("./BaseEpubItem"));
var _BaseEpubItem = _interopRequireDefault(require("./BaseEpubItem"));
var _NavPoint = _interopRequireDefault(require("./NavPoint"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var NcxItem = function (_BaseEpubItem) {
(0, _inherits2["default"])(NcxItem, _BaseEpubItem);
class NcxItem extends _BaseEpubItem.default {
get defaultEncoding() {
return 'utf8';
}
var _super = _createSuper(NcxItem);
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
(0, _createClass2["default"])(NcxItem, [{
key: "defaultEncoding",
get: function get() {
return 'utf8';
}
}]);
_defineProperty(this, "navPoints", void 0);
function NcxItem() {
var _this;
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, NcxItem);
_this = _super.call(this, rawObj, freeze);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "navPoints", void 0);
_this.navPoints = (rawObj.navPoints || []).map(function (navPoint) {
return new _NavPoint["default"](navPoint, freeze);
this.navPoints = (rawObj.navPoints || []).map(navPoint => {
return new _NavPoint.default(navPoint, freeze);
});
if (freeze) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
Object.freeze(this);
}
}
return _this;
toRaw() {
return (0, _parserCore.mergeObjects)(super.toRaw(), {
navPoints: this.navPoints.map(navPoint => navPoint.toRaw()),
itemType: 'NcxItem'
});
}
(0, _createClass2["default"])(NcxItem, [{
key: "toRaw",
value: function toRaw() {
return (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(NcxItem.prototype), "toRaw", this).call(this), {
navPoints: this.navPoints.map(function (navPoint) {
return navPoint.toRaw();
}),
itemType: 'NcxItem'
});
}
}]);
return NcxItem;
}(_BaseEpubItem2["default"]);
}
var _default = NcxItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

114

lib/model/SpineItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _parserCore = require("@ridi/parser-core");
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _BaseEpubItem = _interopRequireDefault(require("./BaseEpubItem"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
class SpineItem extends _BaseEpubItem.default {
get defaultEncoding() {
return 'utf8';
}
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
_defineProperty(this, "first", void 0);
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
_defineProperty(this, "prev", void 0);
var _parserCore = require("@ridi/parser-core");
_defineProperty(this, "next", void 0);
var _BaseEpubItem2 = _interopRequireDefault(require("./BaseEpubItem"));
_defineProperty(this, "index", void 0);
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
_defineProperty(this, "isLinear", void 0);
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
_defineProperty(this, "styles", void 0);
var SpineItem = function (_BaseEpubItem) {
(0, _inherits2["default"])(SpineItem, _BaseEpubItem);
this.index = rawObj.index;
this.isLinear = (0, _parserCore.isExists)(rawObj.isLinear) ? rawObj.isLinear : true;
var _super = _createSuper(SpineItem);
(0, _createClass2["default"])(SpineItem, [{
key: "defaultEncoding",
get: function get() {
return 'utf8';
}
}]);
function SpineItem() {
var _this;
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, SpineItem);
_this = _super.call(this, rawObj, freeze);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "first", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "prev", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "next", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "index", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "isLinear", void 0);
(0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "styles", void 0);
_this.index = rawObj.index;
_this.isLinear = (0, _parserCore.isExists)(rawObj.isLinear) ? rawObj.isLinear : true;
if ((0, _parserCore.isExists)(rawObj.styles)) {
_this.styles = rawObj.styles;
this.styles = rawObj.styles;
}
_this.first = function () {
return undefined;
};
this.first = () => undefined;
_this.prev = function () {
return undefined;
};
this.prev = () => undefined;
_this.next = function () {
return undefined;
};
this.next = () => undefined;
if (freeze) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
Object.freeze(this);
}
return _this;
}
(0, _createClass2["default"])(SpineItem, [{
key: "toRaw",
value: function toRaw() {
var rawObject = (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(SpineItem.prototype), "toRaw", this).call(this), {
index: this.index,
isLinear: this.isLinear,
itemType: 'SpineItem'
toRaw() {
let rawObject = (0, _parserCore.mergeObjects)(super.toRaw(), {
index: this.index,
isLinear: this.isLinear,
itemType: 'SpineItem'
});
if ((0, _parserCore.isExists)(this.styles)) {
rawObject = (0, _parserCore.mergeObjects)(rawObject, {
styles: this.styles.map(style => style.href)
});
}
if ((0, _parserCore.isExists)(this.styles)) {
rawObject = (0, _parserCore.mergeObjects)(rawObject, {
styles: this.styles.map(function (style) {
return style.href;
})
});
}
return rawObject;
}
return rawObject;
}
}]);
return SpineItem;
}(_BaseEpubItem2["default"]);
}
var _default = SpineItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

69

lib/model/SvgItem.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _parserCore = require("@ridi/parser-core");
var _ImageItem2 = _interopRequireDefault(require("./ImageItem"));
var _ImageItem = _interopRequireDefault(require("./ImageItem"));
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
class SvgItem extends _ImageItem.default {
get defaultEncoding() {
return 'utf8';
}
var SvgItem = function (_ImageItem) {
(0, _inherits2["default"])(SvgItem, _ImageItem);
constructor(rawObj = {}, freeze = true) {
super(rawObj, freeze);
var _super = _createSuper(SvgItem);
(0, _createClass2["default"])(SvgItem, [{
key: "defaultEncoding",
get: function get() {
return 'utf8';
}
}]);
function SvgItem() {
var _this;
var rawObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var freeze = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
(0, _classCallCheck2["default"])(this, SvgItem);
_this = _super.call(this, rawObj, freeze);
if (freeze) {
Object.freeze((0, _assertThisInitialized2["default"])(_this));
Object.freeze(this);
}
}
return _this;
toRaw() {
return (0, _parserCore.mergeObjects)(super.toRaw(), {
itemType: 'SvgItem'
});
}
(0, _createClass2["default"])(SvgItem, [{
key: "toRaw",
value: function toRaw() {
return (0, _parserCore.mergeObjects)((0, _get2["default"])((0, _getPrototypeOf2["default"])(SvgItem.prototype), "toRaw", this).call(this), {
itemType: 'SvgItem'
});
}
}]);
return SvgItem;
}(_ImageItem2["default"]);
}
var _default = SvgItem;
exports["default"] = _default;
exports.default = _default;
module.exports = exports.default;

6

package.json
{
"name": "@ridi/epub-parser",
"version": "0.7.3-alpha.0",
"version": "0.7.3-alpha.1",
"description": "Common EPUB2 data parser for Ridibooks services",

@@ -33,3 +33,3 @@ "author": {

"dependencies": {
"@ridi/parser-core": "0.7.3-alpha.0",
"@ridi/parser-core": "0.7.3-alpha.1",
"css-tree": "^1.0.0-alpha.39",

@@ -41,3 +41,3 @@ "fast-xml-parser": "3.12.17",

},
"gitHead": "0043c032feea8e8f83d113ca1bee62be19a4dcee"
"gitHead": "8f819a7c73eaa9642830e00ad8ff4113e0aa8a2c"
}