@abfcode/spine 0.1.0

package/dist/index.js

@@ -0,0 +1,1397 @@
+import { unzipSync, strFromU8 } from 'fflate';
+
+// src/container.ts
+
+// src/util.ts
+function posixClean(p) {
+  if (p === "") return ".";
+  const rooted = p[0] === "/";
+  const out = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length && out[out.length - 1] !== "..") out.pop();
+      else if (!rooted) out.push("..");
+    } else {
+      out.push(seg);
+    }
+  }
+  const res = (rooted ? "/" : "") + out.join("/");
+  return res === "" ? "." : res;
+}
+function posixJoin(...parts) {
+  const joined = parts.filter((p) => p !== "").join("/");
+  return joined === "" ? "" : posixClean(joined);
+}
+function posixDir(p) {
+  const i = p.lastIndexOf("/");
+  const dir = i < 0 ? "" : p.slice(0, i);
+  return posixClean(dir === "" ? i < 0 ? "." : "/" : dir);
+}
+function posixExt(p) {
+  for (let i = p.length - 1; i >= 0 && p[i] !== "/"; i--) {
+    if (p[i] === ".") return p.slice(i);
+  }
+  return "";
+}
+function resolvePath(base, href) {
+  if (href === "") return "";
+  if (href.includes("://") || href.startsWith("data:") || href.startsWith("mailto:")) return href;
+  const hashIdx = href.indexOf("#");
+  let ref = hashIdx === -1 ? href : href.slice(0, hashIdx);
+  const frag = hashIdx === -1 ? "" : href.slice(hashIdx);
+  ref = ref.replace(/^\//, "");
+  if (base === "." || base === "/") base = "";
+  if (base === "") return ref === "" ? frag : posixClean(ref) + frag;
+  if (ref === "") return posixClean(base) + frag;
+  return posixClean(posixJoin(base, ref)) + frag;
+}
+function splitHrefAnchor(href) {
+  const i = href.indexOf("#");
+  return i === -1 ? [href, ""] : [href.slice(0, i), href.slice(i + 1)];
+}
+function anchorKey(href, id) {
+  return href === "" ? "#" + id : href + "#" + id;
+}
+function stableId(...parts) {
+  let h = 2166136261;
+  for (const p of parts) {
+    for (let i = 0; i < p.length; i++) {
+      h ^= p.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+    h ^= 0;
+    h = Math.imul(h, 16777619);
+  }
+  return "id_" + (h >>> 0).toString(16).padStart(8, "0");
+}
+var EXT_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".xhtml": "application/xhtml+xml",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".ncx": "application/x-dtbncx+xml",
+  ".opf": "application/oebps-package+xml"
+};
+function contentTypeFromHref(href) {
+  return EXT_TYPES[posixExt(href).toLowerCase()] ?? "";
+}
+
+// src/dom.ts
+function getDOMParser() {
+  const P = globalThis.DOMParser;
+  if (!P) throw new Error("DOMParser is not available in this environment");
+  return P;
+}
+function parseXml(source) {
+  return new (getDOMParser())().parseFromString(source, "application/xml");
+}
+function parseHtml(source) {
+  return new (getDOMParser())().parseFromString(source, "text/html");
+}
+var ErrMissingContainer = new Error("missing container");
+var ErrNoRootfile = new Error("no rootfile found");
+var ErrNoSpine = new Error("no spine content found");
+
+// src/container.ts
+var Archive = class {
+  byClean = /* @__PURE__ */ new Map();
+  names = [];
+  constructor(bytes) {
+    const raw = unzipSync(bytes);
+    for (const name of Object.keys(raw)) {
+      if (name.endsWith("/")) continue;
+      this.names.push(name);
+      this.byClean.set(this.key(name), raw[name]);
+    }
+  }
+  key(p) {
+    return posixClean(p.replace(/^\//, ""));
+  }
+  has(p) {
+    return this.byClean.has(this.key(p));
+  }
+  bytes(p) {
+    return this.byClean.get(this.key(p));
+  }
+  text(p) {
+    const b = this.bytes(p);
+    return b ? strFromU8(b) : void 0;
+  }
+};
+var CONTAINER_PATH = "META-INF/container.xml";
+function parseContainer(archive) {
+  const xml = archive.text(CONTAINER_PATH);
+  if (xml === void 0) throw ErrMissingContainer;
+  const doc = parseXml(xml);
+  const rootfiles = [...doc.getElementsByTagName("rootfile")];
+  const paths = [];
+  for (const rf of rootfiles) {
+    const full = rf.getAttribute("full-path");
+    if (!full) continue;
+    paths.push(posixClean(full.replace(/^\//, "")));
+  }
+  if (paths.length === 0) throw ErrNoRootfile;
+  return paths;
+}
+function findOpfs(archive) {
+  return archive.names.filter((n) => n.toLowerCase().endsWith(".opf"));
+}
+
+// src/opf.ts
+function emptyMetadata() {
+  return {
+    title: "",
+    titles: [],
+    authors: [],
+    creators: [],
+    contributors: [],
+    language: "",
+    languages: [],
+    identifiers: [],
+    publisher: "",
+    publishers: [],
+    pubDate: "",
+    dates: [],
+    series: "",
+    seriesIndex: "",
+    subjects: [],
+    rights: [],
+    descriptions: [],
+    modified: "",
+    collections: [],
+    coverHref: ""
+  };
+}
+function attr(el, local) {
+  for (const a of Array.from(el.attributes)) {
+    if (a.localName === local) return a.value;
+  }
+  return "";
+}
+function splitProps(s) {
+  const fields = s.split(/\s+/).filter(Boolean);
+  return fields.length ? fields : [];
+}
+function atoiSafe(v) {
+  let n = 0;
+  for (const ch of v.trim()) {
+    if (ch < "0" || ch > "9") return n;
+    n = n * 10 + (ch.charCodeAt(0) - 48);
+  }
+  return n;
+}
+function childByLocal(parent, local) {
+  for (const c of Array.from(parent.children)) if (c.localName === local) return c;
+  return void 0;
+}
+function mkMeta(id, value, lang = "", fileAs = "", role = "") {
+  return { id, value, language: lang, scheme: "", fileAs, role, displaySeq: 0, refinements: {} };
+}
+function parseOpf(xmlText) {
+  const doc = parseXml(xmlText);
+  const pkg = doc.documentElement;
+  const meta = emptyMetadata();
+  const manifest = /* @__PURE__ */ new Map();
+  const spine = [];
+  const data = { metadata: meta, manifest, spine, spineToc: "", coverId: "", version: "" };
+  data.version = (attr(pkg, "version") || "").trim();
+  const refinements = /* @__PURE__ */ new Map();
+  const metaTargets = /* @__PURE__ */ new Map();
+  const identifierTargets = /* @__PURE__ */ new Map();
+  const collectionTargets = /* @__PURE__ */ new Map();
+  const track = (id, mv) => {
+    if (!id) return;
+    const list = metaTargets.get(id) ?? [];
+    list.push(mv);
+    metaTargets.set(id, list);
+  };
+  const metadataEl = childByLocal(pkg, "metadata");
+  if (metadataEl) {
+    for (const el of Array.from(metadataEl.children)) {
+      const name = el.localName;
+      const id = attr(el, "id");
+      const lang = attr(el, "lang");
+      const fileAs = attr(el, "file-as");
+      const role = attr(el, "role");
+      const text = (el.textContent ?? "").trim();
+      switch (name) {
+        case "title":
+          if (text) {
+            const mv = mkMeta(id, text, lang, fileAs, role);
+            meta.titles.push(mv);
+            track(id, mv);
+            if (!meta.title) meta.title = text;
+          }
+          break;
+        case "creator":
+          if (text) {
+            const mv = mkMeta(id, text, lang, fileAs, role);
+            meta.creators.push(mv);
+            track(id, mv);
+            meta.authors.push(text);
+          }
+          break;
+        case "contributor":
+          if (text) {
+            const mv = mkMeta(id, text, lang, fileAs, role);
+            meta.contributors.push(mv);
+            track(id, mv);
+          }
+          break;
+        case "subject":
+          if (text) {
+            const mv = mkMeta(id, text, lang);
+            meta.subjects.push(mv);
+            track(id, mv);
+          }
+          break;
+        case "language":
+          if (text) {
+            if (!meta.language) meta.language = text;
+            meta.languages.push(text);
+          }
+          break;
+        case "identifier":
+          if (text) {
+            const ident = { id, scheme: attr(el, "scheme"), value: text, type: "" };
+            meta.identifiers.push(ident);
+            if (id) identifierTargets.set(id, ident);
+          }
+          break;
+        case "publisher":
+          if (text) {
+            const mv = mkMeta(id, text, lang);
+            meta.publishers.push(mv);
+            track(id, mv);
+            if (!meta.publisher) meta.publisher = text;
+          }
+          break;
+        case "date":
+          if (text) {
+            const mv = mkMeta(id, text, lang);
+            meta.dates.push(mv);
+            track(id, mv);
+            if (!meta.pubDate) meta.pubDate = text;
+          }
+          break;
+        case "description":
+          if (text) {
+            const mv = mkMeta(id, text, lang);
+            meta.descriptions.push(mv);
+            track(id, mv);
+          }
+          break;
+        case "rights":
+          if (text) {
+            const mv = mkMeta(id, text, lang);
+            meta.rights.push(mv);
+            track(id, mv);
+          }
+          break;
+        case "meta": {
+          const nameAttr = attr(el, "name");
+          const content = attr(el, "content");
+          const property = attr(el, "property");
+          const refines = attr(el, "refines").replace(/^#/, "");
+          const idAttr = attr(el, "id");
+          if (nameAttr.toLowerCase() === "cover" && content) data.coverId = content;
+          if (property.endsWith("belongs-to-collection")) {
+            if (text) {
+              const col = { id: idAttr, name: text, type: "", position: "" };
+              meta.collections.push(col);
+              if (idAttr) collectionTargets.set(idAttr, col);
+              if (!meta.series) meta.series = text;
+            }
+            break;
+          }
+          if (property.endsWith("modified")) {
+            if (text) meta.modified = text;
+            break;
+          }
+          if (property && refines) {
+            if (text) {
+              const r = refinements.get(refines) ?? {};
+              r[property] = text;
+              refinements.set(refines, r);
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  const manifestEl = childByLocal(pkg, "manifest");
+  if (manifestEl) {
+    for (const el of Array.from(manifestEl.children)) {
+      if (el.localName !== "item") continue;
+      const item = {
+        id: attr(el, "id"),
+        href: attr(el, "href"),
+        mediaType: attr(el, "media-type"),
+        properties: splitProps(attr(el, "properties")),
+        path: ""
+      };
+      if (item.id) manifest.set(item.id, item);
+    }
+  }
+  const spineEl = childByLocal(pkg, "spine");
+  if (spineEl) {
+    data.spineToc = attr(spineEl, "toc");
+    for (const el of Array.from(spineEl.children)) {
+      if (el.localName !== "itemref") continue;
+      const item = {
+        idRef: attr(el, "idref"),
+        href: "",
+        linear: attr(el, "linear").toLowerCase() !== "no",
+        properties: splitProps(attr(el, "properties"))
+      };
+      if (item.idRef) spine.push(item);
+    }
+  }
+  applyRefinements(metaTargets, identifierTargets, collectionTargets, refinements, meta);
+  return data;
+}
+function applyRefinements(metaTargets, identifierTargets, collectionTargets, refinements, meta) {
+  for (const [id, props] of refinements) {
+    const targets = metaTargets.get(id);
+    if (targets) for (const mv of targets) applyMetaProps(mv, props);
+    const ident = identifierTargets.get(id);
+    if (ident && props["identifier-type"]) ident.type = props["identifier-type"];
+    const col = collectionTargets.get(id);
+    if (col) {
+      if (props["collection-type"]) col.type = props["collection-type"];
+      if (props["group-position"]) {
+        col.position = props["group-position"];
+        if (!meta.seriesIndex) meta.seriesIndex = props["group-position"];
+      }
+    }
+  }
+  for (const col of meta.collections) {
+    if (col.type === "series" && !meta.series) meta.series = col.name;
+    if (col.type === "series" && !meta.seriesIndex) meta.seriesIndex = col.position;
+  }
+  if (!meta.title && meta.titles.length) meta.title = meta.titles[0].value;
+  if (!meta.language && meta.languages.length) meta.language = meta.languages[0];
+  if (!meta.publisher && meta.publishers.length) meta.publisher = meta.publishers[0].value;
+  if (!meta.pubDate && meta.dates.length) meta.pubDate = meta.dates[0].value;
+}
+function applyMetaProps(mv, props) {
+  for (const [k, v] of Object.entries(props)) mv.refinements[k] = v;
+  if (props["file-as"]) mv.fileAs = props["file-as"];
+  if (props["role"]) mv.role = props["role"];
+  if (props["display-seq"]) mv.displaySeq = atoiSafe(props["display-seq"]);
+  if (props["title-type"] && !mv.scheme) mv.scheme = props["title-type"];
+  if (props["date-type"] && !mv.scheme) mv.scheme = props["date-type"];
+}
+function resolveCover(manifest, coverId) {
+  if (coverId) {
+    const item = manifest.get(coverId);
+    if (item) return item.path;
+  }
+  for (const item of manifest.values()) {
+    if (item.properties.includes("cover-image")) return item.path;
+  }
+  return "";
+}
+
+// src/toc.ts
+function resolveTocPath(manifest, spineToc) {
+  if (spineToc) {
+    const item = manifest.get(spineToc);
+    if (item) return item.path;
+  }
+  for (const item of manifest.values()) {
+    if (item.properties.includes("nav")) return item.path;
+  }
+  for (const item of manifest.values()) {
+    if (item.mediaType.toLowerCase() === "application/x-dtbncx+xml" || item.path.toLowerCase().endsWith(".ncx")) {
+      return item.path;
+    }
+  }
+  return "";
+}
+function parseToc(archive, tocPath) {
+  const data = archive.text(tocPath);
+  if (data === void 0) throw new Error("toc not found in archive: " + tocPath);
+  const lower = data.toLowerCase();
+  if (lower.includes("<ncx") || tocPath.toLowerCase().endsWith(".ncx")) {
+    const items = parseNcx(data);
+    assignTocIds(items, []);
+    resolveTocHrefs(items, tocPath);
+    return { toc: items, landmarks: [], pageList: [] };
+  }
+  const nav = parseNav(data);
+  assignTocIds(nav.toc, []);
+  assignTocIds(nav.landmarks, []);
+  assignTocIds(nav.pageList, []);
+  resolveTocHrefs(nav.toc, tocPath);
+  resolveTocHrefs(nav.landmarks, tocPath);
+  resolveTocHrefs(nav.pageList, tocPath);
+  return nav;
+}
+function childByLocal2(parent, local) {
+  for (const c of Array.from(parent.children)) if (c.localName === local) return c;
+  return void 0;
+}
+function childrenByLocal(parent, local) {
+  return Array.from(parent.children).filter((c) => c.localName === local);
+}
+function parseNcx(xmlText) {
+  const doc = parseXml(xmlText);
+  let navMap;
+  for (const el of Array.from(doc.getElementsByTagName("*"))) {
+    if (el.localName === "navMap") {
+      navMap = el;
+      break;
+    }
+  }
+  if (!navMap) return [];
+  const convert = (points) => points.map((p) => {
+    const labelEl = childByLocal2(p, "navLabel");
+    const textEl = labelEl ? childByLocal2(labelEl, "text") : void 0;
+    const label = (textEl?.textContent ?? "").trim();
+    const contentEl = childByLocal2(p, "content");
+    const src = (contentEl?.getAttribute("src") ?? "").trim();
+    return {
+      id: (p.getAttribute("id") ?? "").trim(),
+      label,
+      href: src,
+      children: convert(childrenByLocal(p, "navPoint"))
+    };
+  });
+  return convert(childrenByLocal(navMap, "navPoint"));
+}
+function navTypeFromAttrs(attrs) {
+  const epubType = attrs["epub:type"];
+  if (epubType) {
+    for (const part of epubType.toLowerCase().split(/\s+/)) {
+      if (part === "toc") return "toc";
+      if (part === "landmarks") return "landmarks";
+      if (part === "page-list") return "pageList";
+    }
+  }
+  if (attrs["role"] && attrs["role"].toLowerCase() === "doc-toc") return "toc";
+  return "unknown";
+}
+function parseNav(htmlText) {
+  const doc = parseHtml(htmlText);
+  const toc = [];
+  const landmarks = [];
+  const pageList = [];
+  let stack = [];
+  let curItem = null;
+  let inNav = false;
+  let navType = "unknown";
+  let inLink = false;
+  let linkBuf = "";
+  const root = () => navType === "landmarks" ? landmarks : navType === "pageList" ? pageList : toc;
+  const onStart = (tag, attrs) => {
+    if (tag === "nav") {
+      navType = navTypeFromAttrs(attrs);
+      if (navType !== "unknown") {
+        inNav = true;
+        stack = [root()];
+      }
+      return;
+    }
+    if (!inNav) return;
+    switch (tag) {
+      case "ol":
+      case "ul":
+        if (curItem) stack.push(curItem.children);
+        else if (stack.length >= 1) stack.push(stack[stack.length - 1]);
+        break;
+      case "li": {
+        const list = stack[stack.length - 1];
+        const item = { id: "", label: "", href: "", children: [] };
+        list.push(item);
+        curItem = item;
+        break;
+      }
+      case "a":
+        if (curItem) {
+          curItem.href = attrs["href"] ?? "";
+          inLink = true;
+          linkBuf = "";
+        }
+        break;
+    }
+  };
+  const onEnd = (tag) => {
+    if (tag === "nav" && inNav) {
+      inNav = false;
+      curItem = null;
+      navType = "unknown";
+      stack = [];
+      return;
+    }
+    if (!inNav) return;
+    switch (tag) {
+      case "ol":
+      case "ul":
+        if (stack.length > 1) stack.pop();
+        break;
+      case "li":
+        curItem = null;
+        break;
+      case "a":
+        if (inLink && curItem) {
+          curItem.label = linkBuf.trim();
+          inLink = false;
+          linkBuf = "";
+        }
+        break;
+    }
+  };
+  const onText = (t) => {
+    if (inLink) linkBuf += t;
+  };
+  const walk = (node) => {
+    for (const child of Array.from(node.childNodes)) {
+      if (child.nodeType === 3) {
+        onText(child.data);
+      } else if (child.nodeType === 1) {
+        const el = child;
+        const tag = el.tagName.toLowerCase();
+        const attrs = {};
+        for (const a of Array.from(el.attributes)) attrs[a.name.toLowerCase()] = a.value;
+        onStart(tag, attrs);
+        walk(el);
+        onEnd(tag);
+      }
+    }
+  };
+  walk(doc.documentElement);
+  return { toc, landmarks, pageList };
+}
+function pathToStrings(path) {
+  return path.map((v) => String.fromCharCode(97 + v % 26));
+}
+function assignTocIds(items, path) {
+  items.forEach((item, i) => {
+    const idxPath = [...path, i];
+    if (!item.id) item.id = stableId(...pathToStrings(idxPath), item.href, item.label);
+    if (item.children.length > 0) assignTocIds(item.children, idxPath);
+  });
+}
+function resolveTocHrefs(items, tocPath) {
+  const base = posixDir(tocPath);
+  for (const item of items) {
+    if (item.href) {
+      item.href = item.href.startsWith("#") ? tocPath + item.href : resolvePath(base, item.href);
+    }
+    if (item.children.length > 0) resolveTocHrefs(item.children, tocPath);
+  }
+}
+function flattenToc(items) {
+  const out = [];
+  const walk = (list, depth, parent) => {
+    for (const item of list) {
+      const idx = out.length;
+      out.push({
+        id: item.id,
+        label: item.label,
+        href: item.href,
+        depth,
+        parent,
+        target: item.target
+      });
+      if (item.children.length > 0) walk(item.children, depth + 1, idx);
+    }
+  };
+  walk(items, 0, -1);
+  return out;
+}
+
+// src/chunk.ts
+var DEFAULT_TEXT_OPTIONS = {
+  preserveLineBreaks: true,
+  includeHeadings: true,
+  headingMarkers: false,
+  includeListMarkers: true,
+  includeHorizontalRules: true
+};
+var encoder = new TextEncoder();
+var byteLen = (s) => encoder.encode(s).length;
+function inlineToText(inline, opts) {
+  if (inline.kind === "image") return inline.alt ? inline.alt : "[image]";
+  if (inline.text === "\n" && !opts.preserveLineBreaks) return " ";
+  return inline.text ?? "";
+}
+function inlinesToText(inlines, opts) {
+  let s = "";
+  for (const inline of inlines) {
+    s += inlineToText(inline, opts);
+    if (!s.endsWith(" ")) s += " ";
+  }
+  return s.trim();
+}
+function tableToText(table, opts) {
+  const rows = table.rows.map((row) => row.cells.map((c) => inlinesToText(c.inlines, opts)).join("	"));
+  return rows.join("\n").trim();
+}
+function figureToText(fig, opts) {
+  const caption = inlinesToText(fig.caption, opts);
+  if (caption) return caption;
+  return fig.images.map((img) => inlineToText(img, opts)).join(" ").trim();
+}
+function blockToText(block, opts = DEFAULT_TEXT_OPTIONS) {
+  if (block.table) return tableToText(block.table, opts);
+  if (block.figure) return figureToText(block.figure, opts);
+  if (block.kind === "heading" && !opts.includeHeadings) return "";
+  const inlines = block.inlines ?? [];
+  if (block.kind === "pre" || block.kind === "table") {
+    let s2 = "";
+    for (const inline of inlines) s2 += inline.kind === "image" ? inlineToText(inline, opts) : inline.text ?? "";
+    return s2.replace(/[ \n\t]+$/, "");
+  }
+  let prefix = "";
+  if (block.kind === "list_item" && opts.includeListMarkers) {
+    prefix = block.ordered && (block.listIndex ?? 0) > 0 ? `${block.listIndex}. ` : "- ";
+  }
+  if (block.kind === "hr") return opts.includeHorizontalRules ? "---" : "";
+  if (block.kind === "heading" && opts.headingMarkers) {
+    let level = block.level ?? 1;
+    level = level <= 0 ? 1 : level > 6 ? 6 : level;
+    prefix = "#".repeat(level) + " ";
+  }
+  let s = prefix;
+  for (const inline of inlines) {
+    s += inlineToText(inline, opts);
+    if (!s.endsWith(" ") && !s.endsWith("\n")) s += " ";
+  }
+  return s.trim();
+}
+function chunkBlocks(blocks, href, spineIndex, chunkStart, opts, textOpts, anchorMap, anchorByID, emit) {
+  let current = null;
+  let chunkIndex = chunkStart;
+  let textLen = 0;
+  let offset = 0;
+  const flush = () => {
+    if (!current) return;
+    current.text = current.text.trim();
+    emit(current);
+    offset += textLen;
+    current = null;
+    textLen = 0;
+  };
+  const startChunk = (blockIndex) => {
+    current = {
+      id: stableId(href, String(spineIndex), String(chunkIndex)),
+      text: "",
+      href,
+      spineIndex,
+      blockIndexFrom: blockIndex,
+      blockIndexTo: blockIndex,
+      startOffset: offset,
+      endOffset: offset,
+      anchors: [],
+      blocks: []
+    };
+    chunkIndex++;
+    textLen = 0;
+  };
+  const appendBlock = (block, blockIndex, blockText) => {
+    if (!current) startChunk(blockIndex);
+    const c = current;
+    if (blockText !== "" && c.text !== "") {
+      c.text += "\n\n";
+      textLen += 2;
+    }
+    if (blockText !== "") {
+      c.text += blockText;
+      textLen += byteLen(blockText);
+    }
+    c.blockIndexTo = blockIndex;
+    c.endOffset = offset + textLen;
+    c.blocks.push(block);
+    if (block.anchors && block.anchors.length > 0) {
+      c.anchors.push(...block.anchors);
+      for (const id of block.anchors) {
+        const ref = {
+          spineIndex,
+          blockIndex,
+          chunkId: c.id,
+          offset: offset + textLen - byteLen(blockText),
+          href: href + "#" + id
+        };
+        const key = anchorKey(href, id);
+        if (!anchorMap.has(key)) anchorMap.set(key, ref);
+        if (!anchorByID.has(id)) anchorByID.set(id, ref);
+      }
+    }
+  };
+  blocks.forEach((block, i) => {
+    const text = blockToText(block, textOpts);
+    const blockLen = byteLen(text);
+    if (opts.mode === "size") {
+      if (textLen > 0 && textLen + blockLen > opts.maxChars) flush();
+      appendBlock(block, i, text);
+    } else if (opts.mode === "paragraph") {
+      appendBlock(block, i, text);
+      if (blockLen > 0) flush();
+    } else {
+      appendBlock(block, i, text);
+    }
+  });
+  flush();
+  return chunkIndex;
+}
+function splitFragment(href) {
+  const i = href.indexOf("#");
+  return i === -1 ? [href, ""] : [href.slice(0, i), href.slice(i + 1)];
+}
+function resolveTocAnchors(items, anchors, anchorsByID) {
+  for (const item of items) {
+    if (item.href) {
+      const [base, frag] = splitFragment(item.href);
+      if (frag) {
+        if (base.includes("://") || base.startsWith("data:")) ; else {
+          const byKey = anchors.get(anchorKey(base, frag));
+          const byId = anchorsByID.get(frag);
+          if (byKey) {
+            item.target = { ...byKey, href: base + "#" + frag };
+          } else if (byId) {
+            item.target = { ...byId };
+          }
+        }
+      }
+    }
+    if (item.children.length > 0) resolveTocAnchors(item.children, anchors, anchorsByID);
+  }
+}
+
+// src/xhtml.ts
+function collapseWhitespace(s) {
+  return s.replace(/[\t\n\r\f ]+/g, " ").trim();
+}
+function atoiSafe2(v) {
+  let n = 0;
+  for (const ch of v.trim()) {
+    if (ch < "0" || ch > "9") return n;
+    n = n * 10 + (ch.charCodeAt(0) - 48);
+  }
+  return n;
+}
+function parseXhtmlBlocks(doc) {
+  const blocks = [];
+  let cur = null;
+  let pendingAnchors = [];
+  const listStack = [];
+  let listDepth = 0;
+  let emphDepth = 0;
+  let strongDepth = 0;
+  const linkStack = [];
+  let skipDepth = 0;
+  let blockQuoteDepth = 0;
+  let preDepth = 0;
+  let codeDepth = 0;
+  let tableDepth = 0;
+  let currentTable = null;
+  let currentRow = null;
+  let currentCell = null;
+  let currentFigure = null;
+  let inFigcaption = false;
+  const flush = () => {
+    if (!cur) return;
+    const empty = (!cur.inlines || cur.inlines.length === 0) && (!cur.anchors || cur.anchors.length === 0) && !cur.table && !cur.figure;
+    if (empty) {
+      cur = null;
+      return;
+    }
+    blocks.push(cur);
+    cur = null;
+  };
+  const ensureBlock = (kind, level) => {
+    if (!cur || cur.kind !== kind || kind === "heading" && (cur.level ?? 0) !== level) {
+      flush();
+      cur = { kind, inlines: [], anchors: [] };
+      if (kind === "heading") cur.level = level;
+      if (pendingAnchors.length > 0) {
+        cur.anchors.push(...pendingAnchors);
+        pendingAnchors = [];
+      }
+    }
+  };
+  const addAnchor = (id) => {
+    if (!id) return;
+    if (cur) cur.anchors.push(id);
+    else pendingAnchors.push(id);
+  };
+  const addInline = (inline) => {
+    if (currentCell) {
+      currentCell.inlines.push(inline);
+      return;
+    }
+    if (currentFigure) {
+      if (inline.kind === "image" && !inFigcaption) currentFigure.images.push(inline);
+      else currentFigure.caption.push(inline);
+      return;
+    }
+    if (cur) cur.inlines.push(inline);
+  };
+  const addInlineText = (text, preserve) => {
+    const clean = preserve ? text : collapseWhitespace(text);
+    if (clean.trim() === "") return;
+    let kind = "text";
+    if (emphDepth > 0) kind = "emphasis";
+    if (strongDepth > 0) kind = "strong";
+    if (codeDepth > 0) kind = "code";
+    const inline = { kind, text: clean, emph: emphDepth > 0, strong: strongDepth > 0 };
+    if (linkStack.length > 0) {
+      inline.kind = "link";
+      inline.href = linkStack[linkStack.length - 1];
+    }
+    addInline(inline);
+  };
+  const onStart = (tag, attrs) => {
+    if (tag === "script" || tag === "style" || tag === "head" || tag === "noscript") {
+      skipDepth++;
+      return;
+    }
+    if (skipDepth > 0) return;
+    if (attrs["id"]) addAnchor(attrs["id"]);
+    if (attrs["name"]) addAnchor(attrs["name"]);
+    switch (tag) {
+      case "p":
+        if (blockQuoteDepth > 0) ensureBlock("blockquote", blockQuoteDepth);
+        else ensureBlock("paragraph", 0);
+        break;
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "h5":
+      case "h6":
+        ensureBlock("heading", Number(tag[1]));
+        break;
+      case "li":
+        if (listStack.length > 0) listStack[listStack.length - 1].index++;
+        ensureBlock("list_item", listDepth);
+        if (cur && listStack.length > 0) {
+          cur.ordered = listStack[listStack.length - 1].ordered;
+          cur.listIndex = listStack[listStack.length - 1].index;
+        }
+        break;
+      case "ul":
+      case "ol": {
+        const ordered = tag === "ol";
+        let start = 1;
+        if (ordered && attrs["start"]) {
+          start = atoiSafe2(attrs["start"]);
+          if (start <= 0) start = 1;
+        }
+        listStack.push({ ordered, index: start - 1 });
+        listDepth = listStack.length;
+        break;
+      }
+      case "br":
+        if (!cur) ensureBlock("paragraph", 0);
+        addInline({ kind: "text", text: "\n" });
+        break;
+      case "img":
+        if (!cur) ensureBlock("paragraph", 0);
+        addInline({ kind: "image", src: attrs["src"] ?? "", alt: attrs["alt"] ?? "" });
+        break;
+      case "a":
+        if (attrs["href"]) linkStack.push(attrs["href"]);
+        break;
+      case "em":
+      case "i":
+        emphDepth++;
+        break;
+      case "strong":
+      case "b":
+        strongDepth++;
+        break;
+      case "blockquote":
+        blockQuoteDepth++;
+        break;
+      case "pre":
+        preDepth++;
+        ensureBlock("pre", 0);
+        break;
+      case "code":
+        codeDepth++;
+        if (!cur) ensureBlock("paragraph", 0);
+        break;
+      case "hr":
+        flush();
+        blocks.push({ kind: "hr" });
+        break;
+      case "table":
+        tableDepth++;
+        ensureBlock("table", 0);
+        if (!cur.table) cur.table = { rows: [] };
+        currentTable = cur.table;
+        break;
+      case "tr":
+        if (tableDepth > 0 && currentTable) {
+          const row = { cells: [] };
+          currentTable.rows.push(row);
+          currentRow = row;
+          currentCell = null;
+        }
+        break;
+      case "td":
+      case "th":
+        if (tableDepth > 0 && currentTable) {
+          if (!currentRow) {
+            const row = { cells: [] };
+            currentTable.rows.push(row);
+            currentRow = row;
+          }
+          const cell = { inlines: [], header: tag === "th" };
+          currentRow.cells.push(cell);
+          currentCell = cell;
+        }
+        break;
+      case "figure":
+        ensureBlock("figure", 0);
+        if (!cur.figure) cur.figure = { images: [], caption: [] };
+        currentFigure = cur.figure;
+        break;
+      case "figcaption":
+        if (!cur || cur.kind !== "figure") {
+          ensureBlock("figure", 0);
+          if (!cur.figure) cur.figure = { images: [], caption: [] };
+        }
+        currentFigure = cur.figure;
+        inFigcaption = true;
+        break;
+    }
+  };
+  const onEnd = (tag) => {
+    if (tag === "script" || tag === "style" || tag === "head" || tag === "noscript") {
+      if (skipDepth > 0) skipDepth--;
+      return;
+    }
+    if (skipDepth > 0) return;
+    switch (tag) {
+      case "p":
+      case "li":
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "h5":
+      case "h6":
+        flush();
+        break;
+      case "ul":
+      case "ol":
+        if (listStack.length > 0) listStack.pop();
+        listDepth = listStack.length;
+        break;
+      case "a":
+        if (linkStack.length > 0) linkStack.pop();
+        break;
+      case "em":
+      case "i":
+        if (emphDepth > 0) emphDepth--;
+        break;
+      case "strong":
+      case "b":
+        if (strongDepth > 0) strongDepth--;
+        break;
+      case "blockquote":
+        if (blockQuoteDepth > 0) blockQuoteDepth--;
+        if (cur && cur.kind === "blockquote") flush();
+        break;
+      case "pre":
+        if (preDepth > 0) preDepth--;
+        if (cur && cur.kind === "pre") flush();
+        break;
+      case "code":
+        if (codeDepth > 0) codeDepth--;
+        break;
+      case "table":
+        if (tableDepth > 0) tableDepth--;
+        if (cur && cur.kind === "table") flush();
+        currentTable = null;
+        currentRow = null;
+        currentCell = null;
+        break;
+      case "td":
+      case "th":
+        currentCell = null;
+        break;
+      case "tr":
+        currentRow = null;
+        break;
+      case "figure":
+        if (cur && cur.kind === "figure") flush();
+        currentFigure = null;
+        inFigcaption = false;
+        break;
+      case "figcaption":
+        inFigcaption = false;
+        break;
+    }
+  };
+  const onText = (raw) => {
+    if (skipDepth > 0) return;
+    if (preDepth === 0 && collapseWhitespace(raw) === "") return;
+    if (!cur) {
+      if (blockQuoteDepth > 0) ensureBlock("blockquote", blockQuoteDepth);
+      else ensureBlock("paragraph", 0);
+    }
+    addInlineText(raw, preDepth > 0);
+  };
+  const walk = (node) => {
+    for (const child of Array.from(node.childNodes)) {
+      if (child.nodeType === 3) {
+        onText(child.data);
+      } else if (child.nodeType === 1) {
+        const el = child;
+        const tag = el.tagName.toLowerCase();
+        const attrs = {};
+        for (const a of Array.from(el.attributes)) attrs[a.name.toLowerCase()] = a.value;
+        onStart(tag, attrs);
+        walk(el);
+        onEnd(tag);
+      }
+    }
+  };
+  walk(doc.documentElement);
+  flush();
+  return blocks;
+}
+
+// src/fallback.ts
+function scoreOpf(data) {
+  if (!data) return -1;
+  let score = data.spine.length * 1e3;
+  score += data.manifest.size;
+  if (data.metadata.title) score += 10;
+  return score;
+}
+function selectRootfile(archive, rootfiles) {
+  let bestPath = "";
+  let bestData = null;
+  let bestScore = -1;
+  for (const rf of rootfiles) {
+    const text = archive.text(rf);
+    const data = text === void 0 ? null : parseOpf(text);
+    const score = scoreOpf(data);
+    if (score > bestScore) {
+      bestScore = score;
+      bestPath = rf;
+      bestData = data;
+    }
+  }
+  return { path: bestPath, opf: bestData };
+}
+function baseName(p) {
+  const i = p.lastIndexOf("/");
+  return i === -1 ? p : p.slice(i + 1);
+}
+function isHtmlMedia(media) {
+  const m = media.toLowerCase();
+  return m.includes("xhtml") || m.includes("html");
+}
+function fallbackManifestFromArchive(archive) {
+  const items = /* @__PURE__ */ new Map();
+  const paths = archive.names.filter((n) => {
+    const l = n.toLowerCase();
+    return l.endsWith(".xhtml") || l.endsWith(".html") || l.endsWith(".htm");
+  }).sort();
+  for (const p of paths) {
+    const clean = posixClean(p.replace(/^\//, ""));
+    const id = "item_" + stableId(clean);
+    items.set(id, {
+      id,
+      href: baseName(clean),
+      mediaType: "application/xhtml+xml",
+      properties: [],
+      path: clean
+    });
+  }
+  return items;
+}
+function fallbackSpineFromManifest(manifest) {
+  const items = [...manifest.values()].filter((item) => isHtmlMedia(item.mediaType)).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return items.map((item) => ({ idRef: item.id, href: item.path, linear: true, properties: [] }));
+}
+function scanXhtmlForFallbacks(doc) {
+  const titleEl = doc.querySelector("title");
+  const headingEl = doc.querySelector("h1,h2,h3,h4,h5,h6");
+  const imgEl = doc.querySelector("img");
+  return {
+    title: collapseWhitespace(titleEl?.textContent ?? ""),
+    heading: collapseWhitespace(headingEl?.textContent ?? ""),
+    img: (imgEl?.getAttribute("src") ?? "").trim()
+  };
+}
+
+// src/book.ts
+var DEFAULT_FALLBACKS = {
+  scanArchive: true,
+  inferSpine: true,
+  generateTOC: true,
+  generateMetadata: true
+};
+var DEFAULT_CONFIG = {
+  chunking: { mode: "paragraph", maxChars: 4e3 }};
+var Book = class {
+  metadata = emptyMetadata();
+  toc = [];
+  landmarks = [];
+  pageList = [];
+  manifest = /* @__PURE__ */ new Map();
+  spine = [];
+  warnings = [];
+  anchors = /* @__PURE__ */ new Map();
+  rootfilePath = "";
+  basePath = "";
+  anchorsById = /* @__PURE__ */ new Map();
+  archive;
+  cfg;
+  chunksCache = null;
+  blockCache = /* @__PURE__ */ new Map();
+  constructor(archive, cfg) {
+    this.archive = archive;
+    this.cfg = cfg;
+  }
+  warn(code, message, path = "") {
+    this.warnings.push({ code, message, path });
+  }
+  cleanHref(href) {
+    return splitHrefAnchor(href)[0];
+  }
+  openResource(href) {
+    if (!href) return void 0;
+    return this.archive.bytes(this.cleanHref(href));
+  }
+  documentFor(href) {
+    const text = this.archive.text(this.cleanHref(href));
+    return text === void 0 ? void 0 : parseHtml(text);
+  }
+  blocks(spineIndex) {
+    if (spineIndex < 0 || spineIndex >= this.spine.length) return [];
+    return this.blocksByHref(this.spine[spineIndex].href);
+  }
+  blocksByHref(href) {
+    const clean = this.cleanHref(href);
+    if (!clean) return [];
+    const cached = this.blockCache.get(clean);
+    if (cached) return cached;
+    const text = this.archive.text(clean);
+    if (text === void 0) {
+      this.warn("content", "spine document not found", clean);
+      return [];
+    }
+    const blocks = parseXhtmlBlocks(parseHtml(text));
+    this.blockCache.set(clean, blocks);
+    return blocks;
+  }
+  cover() {
+    const href = this.metadata.coverHref;
+    if (!href) return void 0;
+    const bytes = this.openResource(href);
+    if (!bytes) return void 0;
+    const item = this.manifestItemByPath(href);
+    const contentType = item?.mediaType || contentTypeFromHref(href);
+    return { href, contentType, bytes };
+  }
+  manifestItemByPath(href) {
+    for (const item of this.manifest.values()) {
+      if (item.path === href || item.href === href) return item;
+    }
+    return void 0;
+  }
+  chunks(opts) {
+    if (this.chunksCache) return this.chunksCache;
+    const chunkOpts = opts ?? this.cfg.chunking;
+    const out = [];
+    const anchorMap = /* @__PURE__ */ new Map();
+    const anchorById = /* @__PURE__ */ new Map();
+    let chunkIndex = 0;
+    for (let spineIndex = 0; spineIndex < this.spine.length; spineIndex++) {
+      const item = this.spine[spineIndex];
+      if (!item.href) {
+        this.warn("spine", "missing href for spine item");
+        continue;
+      }
+      const blocks = this.blocksByHref(item.href);
+      chunkIndex = chunkBlocks(
+        blocks,
+        item.href,
+        spineIndex,
+        chunkIndex,
+        chunkOpts,
+        DEFAULT_TEXT_OPTIONS,
+        anchorMap,
+        anchorById,
+        (c) => out.push(c)
+      );
+    }
+    this.anchors = anchorMap;
+    this.anchorsById = anchorById;
+    resolveTocAnchors(this.toc, anchorMap, anchorById);
+    resolveTocAnchors(this.landmarks, anchorMap, anchorById);
+    resolveTocAnchors(this.pageList, anchorMap, anchorById);
+    this.chunksCache = out;
+    return out;
+  }
+  resolveAnchor(href) {
+    if (href.includes("#")) {
+      const direct = this.anchors.get(href);
+      if (direct) return direct;
+      const frag = href.split("#", 2)[1];
+      if (frag !== void 0) return this.anchorsById.get(frag);
+      return void 0;
+    }
+    return this.anchors.get(href) ?? this.anchorsById.get(href);
+  }
+  /** Port of deriveTOCFromHeadings — build a TOC from heading blocks. */
+  deriveTocFromHeadings() {
+    const toc = [];
+    const stack = [{ level: 0, items: toc }];
+    for (const item of this.spine) {
+      if (!item.href) continue;
+      const blocks = this.blocksByHref(item.href);
+      for (const block of blocks) {
+        if (block.kind !== "heading") continue;
+        let label = blockToText(block, DEFAULT_TEXT_OPTIONS);
+        if (!label) label = "Untitled";
+        let level = block.level ?? 0;
+        if (level <= 0) level = 1;
+        while (stack.length > 0 && stack[stack.length - 1].level >= level) stack.pop();
+        const parent = stack[stack.length - 1].items;
+        let href = item.href;
+        if (block.anchors && block.anchors.length > 0) href = anchorKey(item.href, block.anchors[0]);
+        const newItem = { id: "", label, href, children: [] };
+        parent.push(newItem);
+        stack.push({ level, items: newItem.children });
+      }
+    }
+    assignTocIds(toc, []);
+    return toc;
+  }
+  /** Port of fillMissingMetadata. */
+  fillMissingMetadata() {
+    if (this.metadata.title && this.metadata.coverHref) return;
+    if (this.spine.length === 0 || !this.spine[0].href) return;
+    const doc = this.documentFor(this.spine[0].href);
+    if (!doc) return;
+    const { title, heading, img } = scanXhtmlForFallbacks(doc);
+    if (!this.metadata.title) {
+      if (title) this.metadata.title = title;
+      else if (heading) this.metadata.title = heading;
+      else {
+        this.metadata.title = "Unknown";
+        this.warn("metadata", "missing title", this.spine[0].href);
+      }
+    }
+    if (this.metadata.title && this.metadata.titles.length === 0) {
+      this.metadata.titles.push({
+        id: "",
+        value: this.metadata.title,
+        language: "",
+        scheme: "",
+        fileAs: "",
+        role: "",
+        displaySeq: 0,
+        refinements: {}
+      });
+    }
+    if (!this.metadata.coverHref && img) {
+      this.metadata.coverHref = resolvePath(posixDir(this.spine[0].href), img);
+    }
+  }
+};
+function mergeConfig(opts) {
+  return {
+    chunking: opts?.chunking ?? DEFAULT_CONFIG.chunking,
+    rootfilePath: opts?.rootfilePath,
+    fallbacks: { ...DEFAULT_FALLBACKS, ...opts?.fallbacks }
+  };
+}
+function parse(bytes, opts) {
+  const cfg = mergeConfig(opts);
+  const archive = new Archive(bytes);
+  const book = new Book(archive, cfg);
+  let rootfiles = [];
+  try {
+    rootfiles = parseContainer(archive);
+  } catch (e) {
+    book.warn("container", String(e), "META-INF/container.xml");
+    if (cfg.fallbacks.scanArchive) rootfiles = findOpfs(archive);
+    else throw e;
+  }
+  let rootfilePath = cfg.rootfilePath || "";
+  let opf = null;
+  if (!rootfilePath && rootfiles.length > 0) {
+    if (rootfiles.length > 1) {
+      const sel = selectRootfile(archive, rootfiles);
+      rootfilePath = sel.path || rootfiles[0];
+      opf = sel.opf;
+    } else {
+      rootfilePath = rootfiles[0];
+    }
+  }
+  if (rootfilePath && !opf) {
+    const text = archive.text(rootfilePath);
+    opf = text === void 0 ? null : parseOpf(text);
+  }
+  if (!rootfilePath && rootfiles.length === 0) {
+    if (!cfg.fallbacks.scanArchive) throw ErrNoRootfile;
+    book.warn("container", "no rootfile found; scanning archive", "");
+    book.manifest = fallbackManifestFromArchive(archive);
+    if (cfg.fallbacks.inferSpine) book.spine = fallbackSpineFromManifest(book.manifest);
+    if (book.spine.length === 0) throw ErrNoSpine;
+    if (cfg.fallbacks.generateMetadata) book.fillMissingMetadata();
+    if (cfg.fallbacks.generateTOC) book.toc = book.deriveTocFromHeadings();
+    return book;
+  }
+  if (!opf) {
+    opf = { metadata: emptyMetadata(), manifest: /* @__PURE__ */ new Map(), spine: [], spineToc: "", coverId: "", version: "" };
+  }
+  book.rootfilePath = rootfilePath;
+  book.basePath = posixDir(rootfilePath);
+  book.metadata = opf.metadata;
+  book.manifest = opf.manifest;
+  book.spine = opf.spine;
+  for (const [id, item] of book.manifest) {
+    if (!item.path) item.path = resolvePath(book.basePath, item.href);
+    book.manifest.set(id, item);
+  }
+  for (const s of book.spine) {
+    if (!s.href && s.idRef) s.href = book.manifest.get(s.idRef)?.path ?? "";
+  }
+  if (book.manifest.size === 0 && cfg.fallbacks.scanArchive) {
+    book.manifest = fallbackManifestFromArchive(archive);
+  }
+  if (book.spine.length === 0 && cfg.fallbacks.inferSpine) {
+    book.spine = fallbackSpineFromManifest(book.manifest);
+  }
+  const cover = resolveCover(book.manifest, opf.coverId);
+  if (cover) book.metadata.coverHref = cover;
+  if (cfg.fallbacks.generateMetadata) book.fillMissingMetadata();
+  const tocPath = resolveTocPath(book.manifest, opf.spineToc);
+  if (tocPath) {
+    try {
+      const nav = parseToc(archive, tocPath);
+      book.toc = nav.toc;
+      book.landmarks = nav.landmarks;
+      book.pageList = nav.pageList;
+    } catch (e) {
+      book.warn("toc", String(e), tocPath);
+    }
+  }
+  if (book.toc.length === 0 && cfg.fallbacks.generateTOC) {
+    book.toc = book.deriveTocFromHeadings();
+  }
+  return book;
+}
+
+export { Book, blockToText, contentTypeFromHref, flattenToc, parse, posixClean, posixDir, posixJoin, resolvePath };