@epubook/core 0.0.11 → 0.0.12-beta.2

package/dist/index.mjs

@@ -1,24 +1,266 @@
-import * as path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { createDefu } from 'defu';
-import * as path$1 from 'pathe';
-import { strToU8 } from 'fflate';
-import { XMLBuilder } from 'fast-xml-parser';
-import { promises, existsSync, mkdirSync } from 'node:fs';
-
-const Fragment = "Fragment";
-function h(tag, attrs = {}, ...children) {
-  const sub = children.flatMap(
-    (c) => typeof c === "object" && !Array.isArray(c) && c.tag === Fragment ? c.children ?? [] : c
-  ).filter((c) => c !== void 0 && c !== null && c !== false);
-  const o = {
-    tag,
-    attrs: attrs ?? {},
-    children: sub
-  };
-  return o;
-}
-
+import { createDefu } from "defu";
+import * as path from "pathe";
+import { extname } from "pathe";
+import { strToU8 } from "fflate";
+import { XHTMLBuilder } from "@epubook/xml";
+//#region src/utils/defu.ts
+const defu = createDefu((obj, key, value) => {
+	if (obj[key] instanceof Date && value instanceof Date) {
+		obj[key] = value;
+		return true;
+	}
+});
+//#endregion
+//#region src/epub/spine.ts
+var Spine = class {
+	_itemrefs = [];
+	constructor(rendition) {
+		this.rendition = rendition;
+	}
+	get itemrefs() {
+		return this._itemrefs;
+	}
+	shift() {
+		return this._itemrefs.shift();
+	}
+	unshift(ref) {
+		this._itemrefs.unshift(ref);
+		return this;
+	}
+	pop() {
+		return this._itemrefs.pop();
+	}
+	push(...itemrefs) {
+		this._itemrefs.push(...itemrefs);
+		return this;
+	}
+	clear() {
+		this._itemrefs.splice(0, this._itemrefs.length);
+		return this;
+	}
+	[Symbol.iterator]() {
+		return this._itemrefs[Symbol.iterator]();
+	}
+};
+//#endregion
+//#region src/epub/manifest.ts
+var Manifest = class Manifest {
+	_resources = [];
+	constructor(rendition) {
+		this.rendition = rendition;
+	}
+	get resources() {
+		return this._resources;
+	}
+	get items() {
+		return this._resources.map((r) => r.item());
+	}
+	get itemrefs() {
+		return this._resources.map((r) => r.itemref());
+	}
+	add(...resources) {
+		for (const r of resources) {
+			if (this._resources.find((item) => item.id === r.id)) continue;
+			this._resources.push(r);
+		}
+		return this;
+	}
+	[Symbol.iterator]() {
+		return this._resources[Symbol.iterator]();
+	}
+	map(fn) {
+		return this._resources.filter((v, i) => fn(v, i, this));
+	}
+	filter(predicate) {
+		return new Manifest(this.rendition).add(...this._resources.filter((v, i) => predicate(v, i, this)));
+	}
+};
+var Item = class {
+	_href;
+	_id;
+	optional = {};
+	constructor(href, id, info) {
+		this._href = href;
+		this._id = id;
+		info && this.update(info);
+	}
+	update(info) {
+		for (const [key, value] of Object.entries(info)) if (!!value) this.optional[key] = value;
+		return this;
+	}
+	href() {
+		return this._href;
+	}
+	id() {
+		return this._id;
+	}
+	fallback() {
+		return this.optional.fallback;
+	}
+	mediaOverlay() {
+		return this.optional.mediaOverlay;
+	}
+	mediaType() {
+		return this.optional.mediaType;
+	}
+	properties() {
+		return this.optional.properties;
+	}
+	ref() {
+		return new ItemRef(this._id);
+	}
+};
+var ItemRef = class {
+	_idref;
+	optional = {};
+	constructor(idref) {
+		this._idref = idref;
+	}
+	update(info) {
+		for (const [key, value] of Object.entries(info)) if (!!value) this.optional[key] = value;
+		return this;
+	}
+	idref() {
+		return this._idref;
+	}
+	id() {
+		return this.optional.id;
+	}
+	linear() {
+		return this.optional.linear;
+	}
+	properties() {
+		return this.optional.properties;
+	}
+};
+//#endregion
+//#region src/epub/rendition.ts
+var Rendition = class {
+	_fullPath;
+	_specVersion = "3.0";
+	_uniqueIdentifier = "uuid";
+	_identifier = crypto.randomUUID();
+	_metadata = {
+		title: "",
+		language: "zh-CN",
+		contributor: [],
+		coverage: "",
+		creator: {
+			name: "unknown",
+			uid: "creator"
+		},
+		date: /* @__PURE__ */ new Date(),
+		description: "",
+		format: "",
+		publisher: "",
+		relation: "",
+		rights: "",
+		source: "",
+		subject: "",
+		type: "",
+		lastModified: /* @__PURE__ */ new Date()
+	};
+	_cover;
+	_manifest;
+	_spine;
+	_navigation;
+	constructor(fullPath) {
+		this._fullPath = fullPath;
+		this._manifest = new Manifest(this);
+		this._spine = new Spine(this);
+	}
+	get path() {
+		return this._fullPath;
+	}
+	get version() {
+		return this._specVersion;
+	}
+	get title() {
+		return this._metadata.title;
+	}
+	get language() {
+		return this._metadata.language;
+	}
+	get creator() {
+		return this._metadata.creator;
+	}
+	get metadata() {
+		return this._metadata;
+	}
+	get cover() {
+		return this._cover;
+	}
+	updateMetadata(newMetadata) {
+		this._metadata = defu(newMetadata, this._metadata);
+		return this;
+	}
+	get uniqueIdentifier() {
+		return this._uniqueIdentifier;
+	}
+	get identifier() {
+		return this._identifier;
+	}
+	setIdentifier(identifier, uniqueIdentifier = "uuid") {
+		this._identifier = identifier;
+		this._uniqueIdentifier = uniqueIdentifier;
+		return this;
+	}
+	get manifest() {
+		return this._manifest;
+	}
+	get spine() {
+		return this._spine;
+	}
+	get navigation() {
+		return this._navigation;
+	}
+	setNavigation(navigation) {
+		this._navigation = navigation;
+		this._manifest.add(navigation);
+		return this;
+	}
+	setCover(cover) {
+		this._cover = cover;
+		this._manifest.add(cover);
+		return this;
+	}
+	addResource(resource) {
+		this._manifest.add(resource);
+		return this;
+	}
+};
+//#endregion
+//#region src/epub/publication.ts
+var EpubPublication = class EpubPublication {
+	/**
+	* See: https://www.w3.org/TR/epub-33/#sec-package-doc
+	*
+	* Now, it only supports single opf (OEBPS/content.opf)
+	*
+	* @returns list of package documents
+	*/
+	_rootfiles = [];
+	constructor() {}
+	static empty() {
+		return new EpubPublication();
+	}
+	static create(fullPath = "OEBPS/content.opf", rootMeta = {}) {
+		const container = new EpubPublication();
+		const rendition = new Rendition(fullPath);
+		rendition.updateMetadata(rootMeta);
+		container._rootfiles.push(rendition);
+		return container;
+	}
+	get rootfile() {
+		if (this._rootfiles.length === 0) throw new Error("no rendition is provided");
+		return this._rootfiles[0];
+	}
+	get rootfiles() {
+		return this._rootfiles;
+	}
+};
+//#endregion
+//#region src/constant.ts
 const MIMETYPE = "application/epub+zip";
 const ImageGif = "image/gif";
 const ImageJpeg = "image/jpeg";
@@ -28,539 +270,219 @@ const ImageWebp = "image/webp";
 const TextCSS = "text/css";
 const TextXHTML = "application/xhtml+xml";
 function getImageMediaType(file) {
-  const ext = path.extname(file);
-  switch (ext) {
-    case ".gif":
-      return ImageGif;
-    case ".jpg":
-    case ".jpeg":
-      return ImageJpeg;
-    case ".png":
-      return ImagePng;
-    case ".svg":
-      return ImageSvg;
-    case ".webp":
-      return ImageWebp;
-    default:
-      return void 0;
-  }
-}
-
-class ManifestItem {
-  constructor(href, id) {
-    this.optional = {};
-    this._href = href;
-    this._id = id;
-  }
-  update(info) {
-    for (const [key, value] of Object.entries(info)) {
-      if (!!value) {
-        this.optional[key] = value;
-      }
-    }
-    return this;
-  }
-  href() {
-    return this._href;
-  }
-  id() {
-    return this._id;
-  }
-  fallback() {
-    return this.optional.fallback;
-  }
-  mediaOverlay() {
-    return this.optional.mediaOverlay;
-  }
-  mediaType() {
-    return this.optional.mediaType;
-  }
-  properties() {
-    return this.optional.properties;
-  }
-  ref() {
-    return new ManifestItemRef(this._id);
-  }
-}
-class ManifestItemRef {
-  constructor(idref) {
-    this.optional = {};
-    this._idref = idref;
-  }
-  update(info) {
-    for (const [key, value] of Object.entries(info)) {
-      if (!!value) {
-        this.optional[key] = value;
-      }
-    }
-    return this;
-  }
-  idref() {
-    return this._idref;
-  }
-  id() {
-    return this.optional.id;
-  }
-  linear() {
-    return this.optional.linear;
-  }
-  properties() {
-    return this.optional.properties;
-  }
-}
-
-class Item {
-  constructor(file, mediaType) {
-    this.file = file;
-    this.mediaType = mediaType;
-  }
-  filename() {
-    return this.file;
-  }
-  relative(from) {
-    return path$1.relative(path$1.dirname(from), this.file);
-  }
-  update(info) {
-    if (info.properties) {
-      this._properties = info.properties;
-    }
-    return this;
-  }
-  id() {
-    return this.file.replace(/\/|\\/g, "_").replace(/\.[\w]+$/, "");
-  }
-  manifest() {
-    return new ManifestItem(this.file, this.id()).update({
-      mediaType: this.mediaType,
-      properties: this._properties
-    });
-  }
-  itemref() {
-    return this.manifest().ref();
-  }
-}
-class Style extends Item {
-  constructor(file, content) {
-    super(file, TextCSS);
-    this.content = content;
-  }
-  static async read(src, dst) {
-    if (!src.endsWith(".css")) {
-      return void 0;
-    }
-    const content = await promises.readFile(src, "utf-8");
-    return new Style(dst, content);
-  }
-  async bundle() {
-    return strToU8(this.content);
-  }
-}
-class Image extends Item {
-  constructor(file, type, data) {
-    super(file, type);
-    this.data = data;
-  }
-  static async read(file, src) {
-    const content = await promises.readFile(src);
-    const media = getImageMediaType(src);
-    if (media) {
-      return new Image(file, media, content);
-    } else {
-      return void 0;
-    }
-  }
-  async bundle() {
-    return this.data;
-  }
-}
-class HTML extends Item {
-  constructor(file, content) {
-    super(file, TextXHTML);
-    this.content = content;
-  }
-  static async read(src, dst) {
-    if (!src.endsWith(".xhtml")) {
-      return void 0;
-    }
-    const content = await promises.readFile(src, "utf-8");
-    return new HTML(dst, content);
-  }
-  async bundle() {
-    return strToU8(this.content);
-  }
-}
-
-const builder = new XMLBuilder({
-  format: true,
-  ignoreAttributes: false,
-  suppressUnpairedNode: false,
-  unpairedTags: ["link"]
-});
-class XHTML extends Item {
-  constructor(file, meta, content) {
-    super(file, TextXHTML);
-    this._meta = meta;
-    this._content = content;
-  }
-  meta() {
-    return this._meta;
-  }
-  title() {
-    return this._meta.title;
-  }
-  language() {
-    return this._meta.language;
-  }
-  content() {
-    return this._content;
-  }
-  async bundle() {
-    return strToU8(this._content);
-  }
-}
-class XHTMLBuilder {
-  constructor(filename) {
-    this._meta = {
-      language: "en",
-      title: ""
-    };
-    this._head = [];
-    this._body = [];
-    this._bodyAttrs = {};
-    this._filename = filename;
-    this._meta.title = path$1.basename(filename);
-  }
-  language(value) {
-    this._meta.language = value;
-    return this;
-  }
-  title(value) {
-    this._meta.title = value;
-    return this;
-  }
-  style(...list) {
-    for (const href of list) {
-      if (typeof href === "string") {
-        this._head.push({
-          tag: "link",
-          attrs: {
-            href,
-            rel: "stylesheet",
-            type: TextCSS
-          },
-          children: [""]
-        });
-      } else {
-        this._head.push({
-          tag: "link",
-          attrs: {
-            href: href.relative(this._filename),
-            rel: "stylesheet",
-            type: TextCSS
-          },
-          children: [""]
-        });
-      }
-    }
-    return this;
-  }
-  head(...node) {
-    this._head.push(...node);
-    return this;
-  }
-  body(...node) {
-    this._body.push(...node);
-    return this;
-  }
-  bodyAttrs(attrs = {}) {
-    const a = Object.entries(attrs).map(([key, value]) => [`@_${key}`, value]);
-    this._bodyAttrs = {
-      ...this._bodyAttrs,
-      ...Object.fromEntries(a)
-    };
-    return this;
-  }
-  build() {
-    const replacer = {};
-    let content = builder.build({
-      html: {
-        "@_xmlns": "http://www.w3.org/1999/xhtml",
-        "@_xmlns:epub": "http://www.idpf.org/2007/ops",
-        "@_lang": this._meta.language,
-        "@_xml:lang": this._meta.language,
-        head: {
-          title: this._meta.title,
-          ...list(this._head)
-        },
-        body: {
-          ...this._bodyAttrs,
-          ...list(this._body)
-        }
-      }
-    });
-    for (const [key, value] of Object.entries(replacer)) {
-      content = content.replace(key, value);
-    }
-    return new XHTML(this._filename, this._meta, content);
-    function build(node) {
-      const attrs = Object.fromEntries(
-        Object.entries(node.attrs ?? {}).map(([key, value]) => ["@_" + key, value])
-      );
-      if (node.attrs && "html" in node.attrs) {
-        const id = `____${randomUUID()}____`;
-        replacer[id] = node.attrs.html;
-        return { ...attrs, "@_html": void 0, "#text": id };
-      } else {
-        const obj = {
-          ...attrs
-        };
-        if (Array.isArray(node.children)) {
-          const text = node.children.filter((c) => typeof c === "string");
-          const nodes = node.children.filter((c) => typeof c !== "string");
-          if (text.length > 0) {
-            obj["#text"] = text[0];
-          }
-          Object.assign(obj, list(nodes));
-        }
-        return obj;
-      }
-    }
-    function list(list2) {
-      const obj = {};
-      const nodes = list2.flatMap((n) => n.tag === Fragment ? n.children ?? [] : [n]);
-      for (const c of nodes) {
-        if (typeof c === "string") {
-          if (obj["#text"]) {
-            obj["#text"] += c;
-          } else {
-            obj["#text"] = c;
-          }
-        } else if (c.tag in obj) {
-          obj[c.tag].push(build(c));
-        } else {
-          obj[c.tag] = [build(c)];
-        }
-      }
-      return obj;
-    }
-  }
-}
-
-class Toc extends XHTML {
-  constructor(file, meta, content) {
-    super(file, meta, content);
-    this.update({ properties: "nav" });
-  }
-  static from(xhtml) {
-    return new Toc(xhtml.filename(), xhtml.meta(), xhtml.content());
-  }
-  static generate(file, nav, { title = "Nav", heading = 1, titleAttrs = {}, builder } = {}) {
-    if (!builder) {
-      builder = new XHTMLBuilder(file);
-    }
-    const root = {
-      tag: "nav",
-      attrs: {
-        "epub:type": "toc"
-      },
-      children: []
-    };
-    root.children.push(h("h" + heading, titleAttrs, title));
-    root.children.push(/* @__PURE__ */ h("ol", null, list(nav)));
-    return builder.body(root);
-    function list(items) {
-      return items.map(
-        (i) => "page" in i ? /* @__PURE__ */ h("li", { ...i.attrs }, /* @__PURE__ */ h("a", { href: i.page.filename() }, i.title)) : "list" in i ? /* @__PURE__ */ h("li", { ...i.attrs }, /* @__PURE__ */ h("span", null, i.title), /* @__PURE__ */ h("ol", null, list(i.list))) : false
-      );
-    }
-  }
-}
-
-const defu = createDefu((obj, key, value) => {
-  if (obj[key] instanceof Date && value instanceof Date) {
-    obj[key] = value;
-    return true;
-  }
-});
-class PackageDocument {
-  constructor(file) {
-    this.SpecVersion = "3.0";
-    this._uniqueIdentifier = "uuid";
-    this._identifier = randomUUID();
-    this._metadata = {
-      title: "",
-      language: "zh-CN",
-      contributor: [],
-      coverage: "",
-      creator: {
-        name: "unknown",
-        uid: "creator"
-      },
-      date: /* @__PURE__ */ new Date(),
-      description: "",
-      format: "",
-      publisher: "",
-      relation: "",
-      rights: "",
-      source: "",
-      subject: "",
-      type: "",
-      lastModified: /* @__PURE__ */ new Date()
-    };
-    this._items = [];
-    this._spine = [];
-    this.file = file;
-  }
-  filename() {
-    return this.file;
-  }
-  version() {
-    return this.SpecVersion;
-  }
-  // --- metadata ---
-  update(info) {
-    this._metadata = defu(info, this._metadata);
-    return this;
-  }
-  title() {
-    return this._metadata.title;
-  }
-  language() {
-    return this._metadata.language;
-  }
-  creator() {
-    return this._metadata.creator;
-  }
-  metadata() {
-    return this._metadata;
-  }
-  // --- manifest ---
-  addItem(item) {
-    this._items.push(item);
-    return this;
-  }
-  items() {
-    const l = [...this._items];
-    if (this._toc) {
-      l.push(this._toc);
-    }
-    return l;
-  }
-  manifest() {
-    return this.items().map((i) => i.manifest());
-  }
-  // --- navigation ---
-  spine() {
-    return this._spine;
-  }
-  setSpine(items) {
-    this._spine.splice(0, this._spine.length, ...items.map((i) => i.itemref()));
-    return this;
-  }
-  toc() {
-    return this._toc;
-  }
-  setToc(nav, option = {}) {
-    const toc = Toc.generate("nav.xhtml", nav, option);
-    if (!option.builder) {
-      toc.title(option.title ?? "Nav").language(this._metadata.language);
-    }
-    this._toc = Toc.from(toc.build());
-    return this;
-  }
-  // --- identifier ---
-  uniqueIdentifier() {
-    return this._uniqueIdentifier;
-  }
-  identifier() {
-    return this._identifier;
-  }
-  setIdentifier(identifier, uniqueIdentifier = "uuid") {
-    this._identifier = identifier;
-    this._uniqueIdentifier = uniqueIdentifier;
-  }
-}
-
-class Epub {
-  constructor(meta = {}) {
-    /**
-     * See: https://www.w3.org/TR/epub-33/#sec-package-doc
-     *
-     * Now, it only supports single opf (OEBPS/content.opf)
-     *
-     * @returns list of package documents
-     */
-    this.opfs = [new PackageDocument("OEBPS/content.opf")];
-    this.opfs[0].update(meta);
-  }
-  packages() {
-    return this.opfs;
-  }
-  main() {
-    return this.opfs[0];
-  }
-  item(...items) {
-    for (const item of items) {
-      this.opfs[0].addItem(item);
-    }
-    return this;
-  }
-  toc(nav, option = {}) {
-    this.opfs[0].setToc(nav, option);
-    return this;
-  }
-  spine(...items) {
-    this.opfs[0].setSpine(items);
-    return this;
-  }
-  async bundle() {
-    const { bundle } = await import('./chunks/index.mjs');
-    return await bundle(this);
-  }
-  async writeFile(file) {
-    const buffer = await this.bundle();
-    const dir = path$1.dirname(file);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    await promises.writeFile(file, buffer);
-  }
-}
-
-class BundleError extends Error {
-  constructor(msg) {
-    super(msg);
-  }
-}
-
-const UnbuildPreset = ({
-  inject = true
-} = {}) => ({
-  rollup: {
-    esbuild: {
-      jsxFactory: inject ? "__epubook_core.h" : "h",
-      jsxFragment: inject ? "__epubook_core.Fragment" : "Fragment"
-    }
-  },
-  hooks: {
-    "rollup:options"(_options, config) {
-      const plugins = config.plugins;
-      if (inject && Array.isArray(plugins)) {
-        plugins.push(Rollup());
-      }
-    }
-  }
-});
-function Rollup() {
-  return {
-    name: "epubook:inject-tsx",
-    transform(code, id) {
-      if (id.endsWith(".tsx")) {
-        return `import * as __epubook_core from '@epubook/core';
-` + code;
-      }
-    }
-  };
+	switch (extname(file)) {
+		case ".gif": return ImageGif;
+		case ".jpg":
+		case ".jpeg": return ImageJpeg;
+		case ".png": return ImagePng;
+		case ".svg": return ImageSvg;
+		case ".webp": return ImageWebp;
+		default: return;
+	}
 }
-
-export { BundleError, Epub, Fragment, HTML, Image, ImageGif, ImageJpeg, ImagePng, ImageSvg, ImageWebp, Item, MIMETYPE, ManifestItem, ManifestItemRef, PackageDocument, Rollup, Style, TextCSS, TextXHTML, Toc, UnbuildPreset, XHTML, XHTMLBuilder, getImageMediaType, h };
+//#endregion
+//#region src/resource/resource.ts
+var Resource = class {
+	_id;
+	_fullPath;
+	_mediaType;
+	_properties;
+	constructor(id, fullPath, mediaType) {
+		this._id = id || fullPath.replace(/\/|\\/g, "_").replace(/\.[\w]+$/, "");
+		this._fullPath = fullPath;
+		this._mediaType = mediaType;
+	}
+	get id() {
+		return this._id;
+	}
+	get path() {
+		return this._fullPath;
+	}
+	relative(from) {
+		return path.relative(path.dirname(from), this._fullPath);
+	}
+	updateAttrs(info) {
+		if (info.mediaType) this._mediaType = info.mediaType;
+		if (info.properties) this._properties = info.properties;
+		return this;
+	}
+	item() {
+		return new Item(this._fullPath, this._id).update({
+			mediaType: this._mediaType,
+			properties: this._properties
+		});
+	}
+	itemref() {
+		return new ItemRef(this._id);
+	}
+};
+var StyleSheet = class extends Resource {
+	_content;
+	constructor(fullPath, content = "", options = {}) {
+		super(options.id, fullPath, TextCSS);
+		this._content = content;
+	}
+	update(content) {
+		this._content = content;
+		return this;
+	}
+	async bundle() {
+		return strToU8(this._content);
+	}
+};
+var Image = class extends Resource {
+	_data;
+	constructor(fullPath, type, data = void 0, options = {}) {
+		super(options.id, fullPath, type);
+		this._mediaType = type;
+		this._data = data;
+	}
+	update(type, data) {
+		this._mediaType = type;
+		this._data = data;
+		return this;
+	}
+	async bundle() {
+		if (!this._data) return new Uint8Array(0);
+		return this._data;
+	}
+};
+var Cover = class extends Image {
+	constructor(fullPath, type, data = void 0, options = {}) {
+		super(fullPath, type, data, options);
+		this._properties = "cover-image";
+	}
+};
+var XHTML = class extends Resource {
+	_meta;
+	_content;
+	constructor(fullPath, meta = {
+		title: "",
+		language: "en"
+	}, content = void 0, options = {}) {
+		super(options.id, fullPath, TextXHTML);
+		this._meta = {
+			title: "",
+			language: "en",
+			...meta
+		};
+		this._content = content;
+	}
+	get meta() {
+		return this._meta;
+	}
+	get title() {
+		return this._meta.title;
+	}
+	get language() {
+		return this._meta.language;
+	}
+	get content() {
+		return this._content;
+	}
+	update(text) {
+		this._content = text;
+		return this;
+	}
+	async bundle() {
+		return strToU8(this._content || "");
+	}
+};
+//#endregion
+//#region src/resource/navigation.ts
+var Navigation = class extends Resource {
+	_nav = [];
+	_options = {};
+	constructor(fullPath = "nav.xhtml", nav = [], options = {}) {
+		super(void 0, fullPath, TextXHTML);
+		this._properties = "nav";
+		this.update(nav, options);
+	}
+	update(nav, options = {}) {
+		this._nav = nav;
+		this._options = options;
+		return this;
+	}
+	generate() {
+		const builder = new XHTMLBuilder(this._fullPath);
+		if (this._options.title) builder.setTitle(this._options.title);
+		const nav = [];
+		if (this._options.heading?.text || this._options.title) nav.push({
+			type: "element",
+			name: `h${this._options.heading || 1}`,
+			attributes: this._options.heading?.attrs || {},
+			children: [{
+				type: "text",
+				value: this._options.heading?.text || this._options.title
+			}]
+		});
+		const ol = [];
+		const makeAnchorNode = (navItem) => {
+			if ("resource" in navItem) return {
+				type: "element",
+				name: "li",
+				attributes: navItem.attrs || {},
+				children: [{
+					type: "element",
+					name: "a",
+					attributes: { href: navItem.resource.path },
+					children: [{
+						type: "text",
+						value: navItem.title
+					}]
+				}]
+			};
+			else return {
+				type: "element",
+				name: "li",
+				attributes: navItem.attrs || {},
+				children: [{
+					type: "element",
+					name: "a",
+					attributes: { href: navItem.href },
+					children: [{
+						type: "text",
+						value: navItem.title
+					}]
+				}]
+			};
+		};
+		for (const navItem of this._nav) if ("children" in navItem) ol.push({
+			type: "element",
+			name: "li",
+			attributes: navItem.attrs || {},
+			children: [{
+				type: "element",
+				name: "span",
+				attributes: {},
+				children: [{
+					type: "text",
+					value: navItem.title
+				}]
+			}, {
+				type: "element",
+				name: "ol",
+				attributes: {},
+				children: navItem.children.map((subNavItem) => makeAnchorNode(subNavItem))
+			}]
+		});
+		else ol.push(makeAnchorNode(navItem));
+		builder.appendBody({
+			type: "element",
+			name: "nav",
+			attributes: { "epub:type": "toc" },
+			children: [...nav, {
+				type: "element",
+				name: "ol",
+				attributes: {},
+				children: ol
+			}]
+		});
+		return builder.build();
+	}
+	async bundle() {
+		return strToU8(this.generate().content);
+	}
+};
+//#endregion
+export { Cover, EpubPublication, Image, ImageGif, ImageJpeg, ImagePng, ImageSvg, ImageWebp, Item, ItemRef, MIMETYPE, Manifest, Navigation, Rendition, Resource, StyleSheet, TextCSS, TextXHTML, XHTML, getImageMediaType };