wiki-graph-core 0.3.1

package/dist/source/epub/archive.js

@@ -0,0 +1,189 @@
+import { createHash } from "crypto";
+import { posix } from "path";
+import { PassThrough } from "stream";
+import { open } from "yauzl";
+class EpubArchive {
+  #path;
+  #zipFile;
+  #entries;
+  #closed = false;
+  constructor(path, zipFile, entries) {
+    this.#path = path;
+    this.#zipFile = zipFile;
+    this.#entries = entries;
+  }
+  static async open(path) {
+    const zipFile = await openZipFile(path);
+    const entries = await indexEntries(zipFile);
+    return new EpubArchive(path, zipFile, entries);
+  }
+  close() {
+    if (this.#closed) {
+      return Promise.resolve();
+    }
+    this.#closed = true;
+    this.#zipFile.close();
+    return Promise.resolve();
+  }
+  hasEntry(path) {
+    return this.#entries.has(normalizeArchivePath(path));
+  }
+  listEntries() {
+    return [...this.#entries.keys()];
+  }
+  async openReadStream(path) {
+    const entry = this.#getEntry(path);
+    return await openEntryStream(this.#zipFile, entry);
+  }
+  async readText(path) {
+    const stream = await this.openReadStream(path);
+    return (await readStreamToBuffer(stream)).toString("utf8");
+  }
+  async readBuffer(path) {
+    const stream = await this.openReadStream(path);
+    return await readStreamToBuffer(stream);
+  }
+  resolveRelativePath(basePath, href) {
+    const normalizedHref = normalizeHref(href);
+    if (normalizedHref === "") {
+      throw new Error(`Invalid EPUB href: ${href}`);
+    }
+    return normalizeArchivePath(
+      posix.join(posix.dirname(normalizeArchivePath(basePath)), normalizedHref)
+    );
+  }
+  createSectionId(path, fragment) {
+    const normalizedPath = normalizeArchivePath(path);
+    if (fragment === void 0 || fragment === "") {
+      return normalizedPath;
+    }
+    return `${normalizedPath}#${fragment}`;
+  }
+  createSyntheticSectionId(path, title) {
+    const normalizedPath = normalizeArchivePath(path);
+    const hash = createHash("sha1").update(`${normalizedPath}:${title ?? ""}`).digest("hex").slice(0, 10);
+    return `toc:${hash}`;
+  }
+  get path() {
+    return this.#path;
+  }
+  #getEntry(path) {
+    const normalizedPath = normalizeArchivePath(path);
+    const entry = this.#entries.get(normalizedPath);
+    if (entry === void 0) {
+      throw new Error(`EPUB entry does not exist: ${normalizedPath}`);
+    }
+    return entry;
+  }
+}
+function normalizeArchivePath(path) {
+  const normalized = path.replaceAll("\\", "/").trim();
+  const withoutFragment = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+  return posix.normalize(withoutFragment).replace(/^(\.\/)+/, "").replace(/^\/+/, "");
+}
+function normalizeHref(href) {
+  const [path] = href.split("#", 1);
+  return normalizeArchivePath(path ?? "");
+}
+function normalizeFragment(fragment) {
+  if (fragment === void 0) {
+    return void 0;
+  }
+  const normalized = fragment.startsWith("#") ? fragment.slice(1) : fragment;
+  return normalized === "" ? void 0 : normalized;
+}
+function splitHref(href) {
+  const [pathPart, fragmentPart] = href.split("#", 2);
+  return {
+    path: normalizeArchivePath(pathPart ?? ""),
+    fragment: normalizeFragment(fragmentPart)
+  };
+}
+async function openZipFile(path) {
+  return await new Promise((resolve, reject) => {
+    open(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {
+      if (error !== null || zipFile === void 0) {
+        reject(error ?? new Error(`Cannot open EPUB archive: ${path}`));
+        return;
+      }
+      resolve(zipFile);
+    });
+  });
+}
+async function indexEntries(zipFile) {
+  return await new Promise((resolve, reject) => {
+    const entries = /* @__PURE__ */ new Map();
+    zipFile.on("entry", (entry) => {
+      if (entry.fileName.endsWith("/")) {
+        zipFile.readEntry();
+        return;
+      }
+      entries.set(normalizeArchivePath(entry.fileName), entry);
+      zipFile.readEntry();
+    });
+    zipFile.once("end", () => {
+      resolve(entries);
+    });
+    zipFile.once("error", (error) => {
+      reject(error);
+    });
+    zipFile.readEntry();
+  });
+}
+function toBuffer(chunk) {
+  if (Buffer.isBuffer(chunk)) {
+    return chunk;
+  }
+  if (typeof chunk === "string") {
+    return Buffer.from(chunk, "utf8");
+  }
+  throw new Error("Unexpected ZIP stream chunk type");
+}
+async function readStreamToBuffer(stream) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => {
+      chunks.push(toBuffer(chunk));
+    });
+    stream.once("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    stream.once("error", (error) => {
+      reject(error);
+    });
+    stream.resume();
+  });
+}
+async function openEntryStream(zipFile, entry) {
+  return await new Promise((resolve, reject) => {
+    zipFile.openReadStream(entry, (error, stream) => {
+      if (error !== null || stream === void 0) {
+        reject(error ?? new Error(`Cannot open EPUB entry: ${entry.fileName}`));
+        return;
+      }
+      resolve(normalizeEntryStream(stream));
+    });
+  });
+}
+function normalizeEntryStream(stream) {
+  const normalized = new PassThrough();
+  stream.once("error", (error) => {
+    normalized.destroy(error);
+  });
+  normalized.once("close", () => {
+    stream.unpipe(normalized);
+    if (!stream.destroyed) {
+      stream.destroy();
+    }
+  });
+  stream.pipe(normalized);
+  return normalized;
+}
+export {
+  EpubArchive,
+  normalizeArchivePath,
+  normalizeFragment,
+  normalizeHref,
+  splitHref
+};
+//# sourceMappingURL=archive.js.map

package/dist/source/epub/archive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/source/epub/archive.ts"],"sourcesContent":["import { createHash } from \"crypto\";\nimport { posix } from \"path\";\nimport { PassThrough, type Readable } from \"stream\";\nimport type { Entry, ZipFile } from \"yauzl\";\nimport { open } from \"yauzl\";\n\nexport class EpubArchive {\n  readonly #path: string;\n  readonly #zipFile: ZipFile;\n  readonly #entries: ReadonlyMap<string, Entry>;\n  #closed = false;\n\n  public constructor(\n    path: string,\n    zipFile: ZipFile,\n    entries: ReadonlyMap<string, Entry>,\n  ) {\n    this.#path = path;\n    this.#zipFile = zipFile;\n    this.#entries = entries;\n  }\n\n  public static async open(path: string): Promise<EpubArchive> {\n    const zipFile = await openZipFile(path);\n    const entries = await indexEntries(zipFile);\n\n    return new EpubArchive(path, zipFile, entries);\n  }\n\n  public close(): Promise<void> {\n    if (this.#closed) {\n      return Promise.resolve();\n    }\n\n    this.#closed = true;\n    this.#zipFile.close();\n\n    return Promise.resolve();\n  }\n\n  public hasEntry(path: string): boolean {\n    return this.#entries.has(normalizeArchivePath(path));\n  }\n\n  public listEntries(): readonly string[] {\n    return [...this.#entries.keys()];\n  }\n\n  public async openReadStream(path: string): Promise<Readable> {\n    const entry = this.#getEntry(path);\n\n    return await openEntryStream(this.#zipFile, entry);\n  }\n\n  public async readText(path: string): Promise<string> {\n    const stream = await this.openReadStream(path);\n    return (await readStreamToBuffer(stream)).toString(\"utf8\");\n  }\n\n  public async readBuffer(path: string): Promise<Buffer> {\n    const stream = await this.openReadStream(path);\n    return await readStreamToBuffer(stream);\n  }\n\n  public resolveRelativePath(basePath: string, href: string): string {\n    const normalizedHref = normalizeHref(href);\n    if (normalizedHref === \"\") {\n      throw new Error(`Invalid EPUB href: ${href}`);\n    }\n\n    return normalizeArchivePath(\n      posix.join(posix.dirname(normalizeArchivePath(basePath)), normalizedHref),\n    );\n  }\n\n  public createSectionId(path: string, fragment?: string): string {\n    const normalizedPath = normalizeArchivePath(path);\n\n    if (fragment === undefined || fragment === \"\") {\n      return normalizedPath;\n    }\n\n    return `${normalizedPath}#${fragment}`;\n  }\n\n  public createSyntheticSectionId(path: string, title?: string): string {\n    const normalizedPath = normalizeArchivePath(path);\n    const hash = createHash(\"sha1\")\n      .update(`${normalizedPath}:${title ?? \"\"}`)\n      .digest(\"hex\")\n      .slice(0, 10);\n\n    return `toc:${hash}`;\n  }\n\n  public get path(): string {\n    return this.#path;\n  }\n\n  #getEntry(path: string): Entry {\n    const normalizedPath = normalizeArchivePath(path);\n    const entry = this.#entries.get(normalizedPath);\n\n    if (entry === undefined) {\n      throw new Error(`EPUB entry does not exist: ${normalizedPath}`);\n    }\n\n    return entry;\n  }\n}\n\nexport function normalizeArchivePath(path: string): string {\n  const normalized = path.replaceAll(\"\\\\\", \"/\").trim();\n  const withoutFragment = normalized.startsWith(\"/\")\n    ? normalized.slice(1)\n    : normalized;\n\n  return posix\n    .normalize(withoutFragment)\n    .replace(/^(\\.\\/)+/, \"\")\n    .replace(/^\\/+/, \"\");\n}\n\nexport function normalizeHref(href: string): string {\n  const [path] = href.split(\"#\", 1);\n\n  return normalizeArchivePath(path ?? \"\");\n}\n\nexport function normalizeFragment(\n  fragment: string | undefined,\n): string | undefined {\n  if (fragment === undefined) {\n    return undefined;\n  }\n\n  const normalized = fragment.startsWith(\"#\") ? fragment.slice(1) : fragment;\n\n  return normalized === \"\" ? undefined : normalized;\n}\n\nexport function splitHref(href: string): {\n  readonly path: string;\n  readonly fragment: string | undefined;\n} {\n  const [pathPart, fragmentPart] = href.split(\"#\", 2);\n\n  return {\n    path: normalizeArchivePath(pathPart ?? \"\"),\n    fragment: normalizeFragment(fragmentPart),\n  };\n}\n\nasync function openZipFile(path: string): Promise<ZipFile> {\n  return await new Promise((resolve, reject) => {\n    open(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {\n      if (error !== null || zipFile === undefined) {\n        reject(error ?? new Error(`Cannot open EPUB archive: ${path}`));\n        return;\n      }\n\n      resolve(zipFile);\n    });\n  });\n}\n\nasync function indexEntries(\n  zipFile: ZipFile,\n): Promise<ReadonlyMap<string, Entry>> {\n  return await new Promise((resolve, reject) => {\n    const entries = new Map<string, Entry>();\n\n    zipFile.on(\"entry\", (entry: Entry) => {\n      if (entry.fileName.endsWith(\"/\")) {\n        zipFile.readEntry();\n        return;\n      }\n\n      entries.set(normalizeArchivePath(entry.fileName), entry);\n      zipFile.readEntry();\n    });\n    zipFile.once(\"end\", () => {\n      resolve(entries);\n    });\n    zipFile.once(\"error\", (error: Error) => {\n      reject(error);\n    });\n\n    zipFile.readEntry();\n  });\n}\n\nfunction toBuffer(chunk: unknown): Buffer {\n  if (Buffer.isBuffer(chunk)) {\n    return chunk;\n  }\n\n  if (typeof chunk === \"string\") {\n    return Buffer.from(chunk, \"utf8\");\n  }\n\n  throw new Error(\"Unexpected ZIP stream chunk type\");\n}\n\nasync function readStreamToBuffer(stream: Readable): Promise<Buffer> {\n  return await new Promise((resolve, reject) => {\n    const chunks: Buffer[] = [];\n\n    stream.on(\"data\", (chunk: unknown) => {\n      chunks.push(toBuffer(chunk));\n    });\n    stream.once(\"end\", () => {\n      resolve(Buffer.concat(chunks));\n    });\n    stream.once(\"error\", (error: Error) => {\n      reject(error);\n    });\n    stream.resume();\n  });\n}\n\nasync function openEntryStream(\n  zipFile: ZipFile,\n  entry: Entry,\n): Promise<Readable> {\n  return await new Promise((resolve, reject) => {\n    zipFile.openReadStream(entry, (error, stream) => {\n      if (error !== null || stream === undefined) {\n        reject(error ?? new Error(`Cannot open EPUB entry: ${entry.fileName}`));\n        return;\n      }\n\n      resolve(normalizeEntryStream(stream));\n    });\n  });\n}\n\nfunction normalizeEntryStream(stream: Readable): Readable {\n  const normalized = new PassThrough();\n\n  stream.once(\"error\", (error: Error) => {\n    normalized.destroy(error);\n  });\n  normalized.once(\"close\", () => {\n    stream.unpipe(normalized);\n\n    if (!stream.destroyed) {\n      stream.destroy();\n    }\n  });\n\n  stream.pipe(normalized);\n\n  return normalized;\n}\n"],"mappings":"AAAA,SAAS,kBAAkB;AAC3B,SAAS,aAAa;AACtB,SAAS,mBAAkC;AAE3C,SAAS,YAAY;AAEd,MAAM,YAAY;AAAA,EACd;AAAA,EACA;AAAA,EACA;AAAA,EACT,UAAU;AAAA,EAEH,YACL,MACA,SACA,SACA;AACA,SAAK,QAAQ;AACb,SAAK,WAAW;AAChB,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,aAAoB,KAAK,MAAoC;AAC3D,UAAM,UAAU,MAAM,YAAY,IAAI;AACtC,UAAM,UAAU,MAAM,aAAa,OAAO;AAE1C,WAAO,IAAI,YAAY,MAAM,SAAS,OAAO;AAAA,EAC/C;AAAA,EAEO,QAAuB;AAC5B,QAAI,KAAK,SAAS;AAChB,aAAO,QAAQ,QAAQ;AAAA,IACzB;AAEA,SAAK,UAAU;AACf,SAAK,SAAS,MAAM;AAEpB,WAAO,QAAQ,QAAQ;AAAA,EACzB;AAAA,EAEO,SAAS,MAAuB;AACrC,WAAO,KAAK,SAAS,IAAI,qBAAqB,IAAI,CAAC;AAAA,EACrD;AAAA,EAEO,cAAiC;AACtC,WAAO,CAAC,GAAG,KAAK,SAAS,KAAK,CAAC;AAAA,EACjC;AAAA,EAEA,MAAa,eAAe,MAAiC;AAC3D,UAAM,QAAQ,KAAK,UAAU,IAAI;AAEjC,WAAO,MAAM,gBAAgB,KAAK,UAAU,KAAK;AAAA,EACnD;AAAA,EAEA,MAAa,SAAS,MAA+B;AACnD,UAAM,SAAS,MAAM,KAAK,eAAe,IAAI;AAC7C,YAAQ,MAAM,mBAAmB,MAAM,GAAG,SAAS,MAAM;AAAA,EAC3D;AAAA,EAEA,MAAa,WAAW,MAA+B;AACrD,UAAM,SAAS,MAAM,KAAK,eAAe,IAAI;AAC7C,WAAO,MAAM,mBAAmB,MAAM;AAAA,EACxC;AAAA,EAEO,oBAAoB,UAAkB,MAAsB;AACjE,UAAM,iBAAiB,cAAc,IAAI;AACzC,QAAI,mBAAmB,IAAI;AACzB,YAAM,IAAI,MAAM,sBAAsB,IAAI,EAAE;AAAA,IAC9C;AAEA,WAAO;AAAA,MACL,MAAM,KAAK,MAAM,QAAQ,qBAAqB,QAAQ,CAAC,GAAG,cAAc;AAAA,IAC1E;AAAA,EACF;AAAA,EAEO,gBAAgB,MAAc,UAA2B;AAC9D,UAAM,iBAAiB,qBAAqB,IAAI;AAEhD,QAAI,aAAa,UAAa,aAAa,IAAI;AAC7C,aAAO;AAAA,IACT;AAEA,WAAO,GAAG,cAAc,IAAI,QAAQ;AAAA,EACtC;AAAA,EAEO,yBAAyB,MAAc,OAAwB;AACpE,UAAM,iBAAiB,qBAAqB,IAAI;AAChD,UAAM,OAAO,WAAW,MAAM,EAC3B,OAAO,GAAG,cAAc,IAAI,SAAS,EAAE,EAAE,EACzC,OAAO,KAAK,EACZ,MAAM,GAAG,EAAE;AAEd,WAAO,OAAO,IAAI;AAAA,EACpB;AAAA,EAEA,IAAW,OAAe;AACxB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,UAAU,MAAqB;AAC7B,UAAM,iBAAiB,qBAAqB,IAAI;AAChD,UAAM,QAAQ,KAAK,SAAS,IAAI,cAAc;AAE9C,QAAI,UAAU,QAAW;AACvB,YAAM,IAAI,MAAM,8BAA8B,cAAc,EAAE;AAAA,IAChE;AAEA,WAAO;AAAA,EACT;AACF;AAEO,SAAS,qBAAqB,MAAsB;AACzD,QAAM,aAAa,KAAK,WAAW,MAAM,GAAG,EAAE,KAAK;AACnD,QAAM,kBAAkB,WAAW,WAAW,GAAG,IAC7C,WAAW,MAAM,CAAC,IAClB;AAEJ,SAAO,MACJ,UAAU,eAAe,EACzB,QAAQ,YAAY,EAAE,EACtB,QAAQ,QAAQ,EAAE;AACvB;AAEO,SAAS,cAAc,MAAsB;AAClD,QAAM,CAAC,IAAI,IAAI,KAAK,MAAM,KAAK,CAAC;AAEhC,SAAO,qBAAqB,QAAQ,EAAE;AACxC;AAEO,SAAS,kBACd,UACoB;AACpB,MAAI,aAAa,QAAW;AAC1B,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,SAAS,WAAW,GAAG,IAAI,SAAS,MAAM,CAAC,IAAI;AAElE,SAAO,eAAe,KAAK,SAAY;AACzC;AAEO,SAAS,UAAU,MAGxB;AACA,QAAM,CAAC,UAAU,YAAY,IAAI,KAAK,MAAM,KAAK,CAAC;AAElD,SAAO;AAAA,IACL,MAAM,qBAAqB,YAAY,EAAE;AAAA,IACzC,UAAU,kBAAkB,YAAY;AAAA,EAC1C;AACF;AAEA,eAAe,YAAY,MAAgC;AACzD,SAAO,MAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,SAAK,MAAM,EAAE,WAAW,OAAO,aAAa,KAAK,GAAG,CAAC,OAAO,YAAY;AACtE,UAAI,UAAU,QAAQ,YAAY,QAAW;AAC3C,eAAO,SAAS,IAAI,MAAM,6BAA6B,IAAI,EAAE,CAAC;AAC9D;AAAA,MACF;AAEA,cAAQ,OAAO;AAAA,IACjB,CAAC;AAAA,EACH,CAAC;AACH;AAEA,eAAe,aACb,SACqC;AACrC,SAAO,MAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,UAAM,UAAU,oBAAI,IAAmB;AAEvC,YAAQ,GAAG,SAAS,CAAC,UAAiB;AACpC,UAAI,MAAM,SAAS,SAAS,GAAG,GAAG;AAChC,gBAAQ,UAAU;AAClB;AAAA,MACF;AAEA,cAAQ,IAAI,qBAAqB,MAAM,QAAQ,GAAG,KAAK;AACvD,cAAQ,UAAU;AAAA,IACpB,CAAC;AACD,YAAQ,KAAK,OAAO,MAAM;AACxB,cAAQ,OAAO;AAAA,IACjB,CAAC;AACD,YAAQ,KAAK,SAAS,CAAC,UAAiB;AACtC,aAAO,KAAK;AAAA,IACd,CAAC;AAED,YAAQ,UAAU;AAAA,EACpB,CAAC;AACH;AAEA,SAAS,SAAS,OAAwB;AACxC,MAAI,OAAO,SAAS,KAAK,GAAG;AAC1B,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,OAAO,KAAK,OAAO,MAAM;AAAA,EAClC;AAEA,QAAM,IAAI,MAAM,kCAAkC;AACpD;AAEA,eAAe,mBAAmB,QAAmC;AACnE,SAAO,MAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,UAAM,SAAmB,CAAC;AAE1B,WAAO,GAAG,QAAQ,CAAC,UAAmB;AACpC,aAAO,KAAK,SAAS,KAAK,CAAC;AAAA,IAC7B,CAAC;AACD,WAAO,KAAK,OAAO,MAAM;AACvB,cAAQ,OAAO,OAAO,MAAM,CAAC;AAAA,IAC/B,CAAC;AACD,WAAO,KAAK,SAAS,CAAC,UAAiB;AACrC,aAAO,KAAK;AAAA,IACd,CAAC;AACD,WAAO,OAAO;AAAA,EAChB,CAAC;AACH;AAEA,eAAe,gBACb,SACA,OACmB;AACnB,SAAO,MAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,YAAQ,eAAe,OAAO,CAAC,OAAO,WAAW;AAC/C,UAAI,UAAU,QAAQ,WAAW,QAAW;AAC1C,eAAO,SAAS,IAAI,MAAM,2BAA2B,MAAM,QAAQ,EAAE,CAAC;AACtE;AAAA,MACF;AAEA,cAAQ,qBAAqB,MAAM,CAAC;AAAA,IACtC,CAAC;AAAA,EACH,CAAC;AACH;AAEA,SAAS,qBAAqB,QAA4B;AACxD,QAAM,aAAa,IAAI,YAAY;AAEnC,SAAO,KAAK,SAAS,CAAC,UAAiB;AACrC,eAAW,QAAQ,KAAK;AAAA,EAC1B,CAAC;AACD,aAAW,KAAK,SAAS,MAAM;AAC7B,WAAO,OAAO,UAAU;AAExB,QAAI,CAAC,OAAO,WAAW;AACrB,aAAO,QAAQ;AAAA,IACjB;AAAA,EACF,CAAC;AAED,SAAO,KAAK,UAAU;AAEtB,SAAO;AACT;","names":[]}

package/dist/source/epub/content.d.ts

@@ -0,0 +1,22 @@
+import { SourceTextStream } from '../types.js';
+import { EpubArchive } from './archive.js';
+import 'stream';
+import 'yauzl';
+
+interface EpubSectionTarget {
+    readonly id: string;
+    readonly path: string;
+    readonly fragment: string | undefined;
+}
+interface EpubSectionAnalysis {
+    readonly hasContent: boolean;
+    readonly wordsCount: number;
+}
+declare class EpubContentLoader {
+    #private;
+    constructor(archive: EpubArchive, targetsByPath: ReadonlyMap<string, readonly EpubSectionTarget[]>);
+    openSection(sectionId: string): Promise<SourceTextStream>;
+}
+declare function analyzeSectionTargets(archive: Pick<EpubArchive, "openReadStream">, targetsByPath: ReadonlyMap<string, readonly EpubSectionTarget[]>): Promise<ReadonlyMap<string, EpubSectionAnalysis>>;
+
+export { EpubContentLoader, type EpubSectionAnalysis, type EpubSectionTarget, analyzeSectionTargets };

package/dist/source/epub/content.js

@@ -0,0 +1,183 @@
+import { Parser } from "htmlparser2";
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "br",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "figcaption",
+  "figure",
+  "footer",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "td",
+  "th",
+  "tr",
+  "ul"
+]);
+const SKIPPED_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
+class EpubContentLoader {
+  #archive;
+  #targetsBySectionId;
+  constructor(archive, targetsByPath) {
+    this.#archive = archive;
+    this.#targetsBySectionId = createTargetsBySectionId(targetsByPath);
+  }
+  async openSection(sectionId) {
+    const target = this.#targetsBySectionId.get(sectionId);
+    if (target === void 0) {
+      return [];
+    }
+    const sections = await this.#parseSections(target.path, target.targets);
+    return [sections.get(sectionId) ?? ""];
+  }
+  async #parseSections(path, targets) {
+    const stream = await this.#archive.openReadStream(path);
+    stream.setEncoding("utf8");
+    return await parseHtmlSections(stream, targets);
+  }
+}
+async function analyzeSectionTargets(archive, targetsByPath) {
+  const analyses = /* @__PURE__ */ new Map();
+  for (const [path, targets] of targetsByPath.entries()) {
+    const stream = await archive.openReadStream(path);
+    stream.setEncoding("utf8");
+    const sections = await parseHtmlSectionTexts(stream, targets);
+    for (const target of targets) {
+      const text = sections.get(target.id) ?? "";
+      analyses.set(target.id, {
+        hasContent: text.trim() !== "",
+        wordsCount: countWords(text)
+      });
+    }
+  }
+  return analyses;
+}
+function createTargetsBySectionId(targetsByPath) {
+  const targetsBySectionId = /* @__PURE__ */ new Map();
+  for (const [path, targets] of targetsByPath.entries()) {
+    for (const target of targets) {
+      targetsBySectionId.set(target.id, { path, targets });
+    }
+  }
+  return targetsBySectionId;
+}
+async function parseHtmlSections(stream, targets) {
+  return await parseHtmlSectionTexts(stream, targets);
+}
+async function parseHtmlSectionTexts(stream, targets) {
+  const fragments = /* @__PURE__ */ new Map();
+  const sections = /* @__PURE__ */ new Map();
+  const orderedTargets = [...targets];
+  const buffers = orderedTargets.map(() => "");
+  const rootSectionIndex = orderedTargets[0]?.fragment === void 0 && orderedTargets[0] !== void 0 ? 0 : -1;
+  let currentIndex = rootSectionIndex;
+  let skippedTagDepth = 0;
+  orderedTargets.forEach((target, index) => {
+    sections.set(target.id, "");
+    if (target.fragment !== void 0 && !fragments.has(target.fragment)) {
+      fragments.set(target.fragment, index);
+    }
+  });
+  const parser = new Parser(
+    {
+      onopentag(name, attributes) {
+        const tagName = name.toLowerCase();
+        if (SKIPPED_TAGS.has(tagName)) {
+          skippedTagDepth += 1;
+          return;
+        }
+        const anchorId = attributes.id ?? attributes["xml:id"];
+        if (anchorId !== void 0) {
+          const nextIndex = fragments.get(anchorId);
+          if (nextIndex !== void 0 && nextIndex > currentIndex) {
+            currentIndex = nextIndex;
+          }
+        }
+        if (tagName === "br") {
+          appendText(buffers, currentIndex, "\n");
+        }
+      },
+      ontext(text) {
+        if (skippedTagDepth > 0) {
+          return;
+        }
+        appendText(buffers, currentIndex, text);
+      },
+      onclosetag(name) {
+        const tagName = name.toLowerCase();
+        if (SKIPPED_TAGS.has(tagName)) {
+          skippedTagDepth = Math.max(0, skippedTagDepth - 1);
+          return;
+        }
+        if (BLOCK_TAGS.has(tagName)) {
+          appendText(buffers, currentIndex, "\n\n");
+        }
+      }
+    },
+    { decodeEntities: true }
+  );
+  for await (const chunk of stream) {
+    parser.write(toTextChunk(chunk));
+  }
+  parser.end();
+  orderedTargets.forEach((target, index) => {
+    sections.set(target.id, normalizeSectionText(buffers[index] ?? ""));
+  });
+  return sections;
+}
+function appendText(buffers, currentIndex, text) {
+  if (currentIndex < 0 || currentIndex >= buffers.length) {
+    return;
+  }
+  buffers[currentIndex] += text;
+}
+function normalizeSectionText(text) {
+  return text.replace(/\r\n/gu, "\n").replace(/\n{3,}/gu, "\n\n").trim();
+}
+function toTextChunk(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (Buffer.isBuffer(chunk)) {
+    return chunk.toString("utf8");
+  }
+  throw new Error("Unexpected HTML stream chunk type");
+}
+function countWords(text) {
+  return [...createWordSegmenter().segment(text)].filter(
+    (segment) => segment.isWordLike
+  ).length;
+}
+let WORD_SEGMENTER;
+function createWordSegmenter() {
+  if (WORD_SEGMENTER === void 0) {
+    WORD_SEGMENTER = new Intl.Segmenter(void 0, {
+      granularity: "word"
+    });
+  }
+  return WORD_SEGMENTER;
+}
+export {
+  EpubContentLoader,
+  analyzeSectionTargets
+};
+//# sourceMappingURL=content.js.map

package/dist/source/epub/content.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/source/epub/content.ts"],"sourcesContent":["import type { Readable } from \"stream\";\n\nimport { Parser } from \"htmlparser2\";\n\nimport type { SourceTextStream } from \"../types.js\";\nimport type { EpubArchive } from \"./archive.js\";\n\nconst BLOCK_TAGS = new Set([\n  \"address\",\n  \"article\",\n  \"aside\",\n  \"blockquote\",\n  \"br\",\n  \"dd\",\n  \"div\",\n  \"dl\",\n  \"dt\",\n  \"figcaption\",\n  \"figure\",\n  \"footer\",\n  \"h1\",\n  \"h2\",\n  \"h3\",\n  \"h4\",\n  \"h5\",\n  \"h6\",\n  \"header\",\n  \"hr\",\n  \"li\",\n  \"main\",\n  \"nav\",\n  \"ol\",\n  \"p\",\n  \"pre\",\n  \"section\",\n  \"table\",\n  \"td\",\n  \"th\",\n  \"tr\",\n  \"ul\",\n]);\n\nconst SKIPPED_TAGS = new Set([\"script\", \"style\"]);\n\nexport interface EpubSectionTarget {\n  readonly id: string;\n  readonly path: string;\n  readonly fragment: string | undefined;\n}\n\nexport interface EpubSectionAnalysis {\n  readonly hasContent: boolean;\n  readonly wordsCount: number;\n}\n\nexport class EpubContentLoader {\n  readonly #archive: EpubArchive;\n  readonly #targetsBySectionId: ReadonlyMap<\n    string,\n    {\n      readonly path: string;\n      readonly targets: readonly EpubSectionTarget[];\n    }\n  >;\n\n  public constructor(\n    archive: EpubArchive,\n    targetsByPath: ReadonlyMap<string, readonly EpubSectionTarget[]>,\n  ) {\n    this.#archive = archive;\n    this.#targetsBySectionId = createTargetsBySectionId(targetsByPath);\n  }\n\n  public async openSection(sectionId: string): Promise<SourceTextStream> {\n    const target = this.#targetsBySectionId.get(sectionId);\n\n    if (target === undefined) {\n      return [];\n    }\n\n    const sections = await this.#parseSections(target.path, target.targets);\n\n    return [sections.get(sectionId) ?? \"\"];\n  }\n\n  async #parseSections(\n    path: string,\n    targets: readonly EpubSectionTarget[],\n  ): Promise<ReadonlyMap<string, string>> {\n    const stream = await this.#archive.openReadStream(path);\n    stream.setEncoding(\"utf8\");\n\n    return await parseHtmlSections(stream, targets);\n  }\n}\n\nexport async function analyzeSectionTargets(\n  archive: Pick<EpubArchive, \"openReadStream\">,\n  targetsByPath: ReadonlyMap<string, readonly EpubSectionTarget[]>,\n): Promise<ReadonlyMap<string, EpubSectionAnalysis>> {\n  const analyses = new Map<string, EpubSectionAnalysis>();\n\n  for (const [path, targets] of targetsByPath.entries()) {\n    const stream = await archive.openReadStream(path);\n    stream.setEncoding(\"utf8\");\n    const sections = await parseHtmlSectionTexts(stream, targets);\n\n    for (const target of targets) {\n      const text = sections.get(target.id) ?? \"\";\n\n      analyses.set(target.id, {\n        hasContent: text.trim() !== \"\",\n        wordsCount: countWords(text),\n      });\n    }\n  }\n\n  return analyses;\n}\n\nfunction createTargetsBySectionId(\n  targetsByPath: ReadonlyMap<string, readonly EpubSectionTarget[]>,\n): ReadonlyMap<\n  string,\n  {\n    readonly path: string;\n    readonly targets: readonly EpubSectionTarget[];\n  }\n> {\n  const targetsBySectionId = new Map<\n    string,\n    {\n      readonly path: string;\n      readonly targets: readonly EpubSectionTarget[];\n    }\n  >();\n\n  for (const [path, targets] of targetsByPath.entries()) {\n    for (const target of targets) {\n      targetsBySectionId.set(target.id, { path, targets });\n    }\n  }\n\n  return targetsBySectionId;\n}\n\nasync function parseHtmlSections(\n  stream: Readable,\n  targets: readonly EpubSectionTarget[],\n): Promise<ReadonlyMap<string, string>> {\n  return await parseHtmlSectionTexts(stream, targets);\n}\n\nasync function parseHtmlSectionTexts(\n  stream: Readable,\n  targets: readonly EpubSectionTarget[],\n): Promise<ReadonlyMap<string, string>> {\n  const fragments = new Map<string, number>();\n  const sections = new Map<string, string>();\n  const orderedTargets = [...targets];\n  const buffers = orderedTargets.map(() => \"\");\n  const rootSectionIndex =\n    orderedTargets[0]?.fragment === undefined && orderedTargets[0] !== undefined\n      ? 0\n      : -1;\n  let currentIndex = rootSectionIndex;\n  let skippedTagDepth = 0;\n\n  orderedTargets.forEach((target, index) => {\n    sections.set(target.id, \"\");\n    if (target.fragment !== undefined && !fragments.has(target.fragment)) {\n      fragments.set(target.fragment, index);\n    }\n  });\n\n  const parser = new Parser(\n    {\n      onopentag(name, attributes) {\n        const tagName = name.toLowerCase();\n        if (SKIPPED_TAGS.has(tagName)) {\n          skippedTagDepth += 1;\n          return;\n        }\n\n        const anchorId = attributes.id ?? attributes[\"xml:id\"];\n        if (anchorId !== undefined) {\n          const nextIndex = fragments.get(anchorId);\n          if (nextIndex !== undefined && nextIndex > currentIndex) {\n            currentIndex = nextIndex;\n          }\n        }\n\n        if (tagName === \"br\") {\n          appendText(buffers, currentIndex, \"\\n\");\n        }\n      },\n      ontext(text) {\n        if (skippedTagDepth > 0) {\n          return;\n        }\n\n        appendText(buffers, currentIndex, text);\n      },\n      onclosetag(name) {\n        const tagName = name.toLowerCase();\n        if (SKIPPED_TAGS.has(tagName)) {\n          skippedTagDepth = Math.max(0, skippedTagDepth - 1);\n          return;\n        }\n\n        if (BLOCK_TAGS.has(tagName)) {\n          appendText(buffers, currentIndex, \"\\n\\n\");\n        }\n      },\n    },\n    { decodeEntities: true },\n  );\n\n  for await (const chunk of stream as AsyncIterable<unknown>) {\n    parser.write(toTextChunk(chunk));\n  }\n\n  parser.end();\n\n  orderedTargets.forEach((target, index) => {\n    sections.set(target.id, normalizeSectionText(buffers[index] ?? \"\"));\n  });\n\n  return sections;\n}\n\nfunction appendText(\n  buffers: string[],\n  currentIndex: number,\n  text: string,\n): void {\n  if (currentIndex < 0 || currentIndex >= buffers.length) {\n    return;\n  }\n\n  buffers[currentIndex] += text;\n}\n\nfunction normalizeSectionText(text: string): string {\n  return text\n    .replace(/\\r\\n/gu, \"\\n\")\n    .replace(/\\n{3,}/gu, \"\\n\\n\")\n    .trim();\n}\n\nfunction toTextChunk(chunk: unknown): string {\n  if (typeof chunk === \"string\") {\n    return chunk;\n  }\n\n  if (Buffer.isBuffer(chunk)) {\n    return chunk.toString(\"utf8\");\n  }\n\n  throw new Error(\"Unexpected HTML stream chunk type\");\n}\n\nfunction countWords(text: string): number {\n  return [...createWordSegmenter().segment(text)].filter(\n    (segment) => segment.isWordLike,\n  ).length;\n}\n\nlet WORD_SEGMENTER: Intl.Segmenter | undefined;\n\nfunction createWordSegmenter(): Intl.Segmenter {\n  if (WORD_SEGMENTER === undefined) {\n    WORD_SEGMENTER = new Intl.Segmenter(undefined, {\n      granularity: \"word\",\n    });\n  }\n\n  return WORD_SEGMENTER;\n}\n"],"mappings":"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","names":[]}

package/dist/source/epub/document.d.ts

@@ -0,0 +1,55 @@
+import { SourceAdapter, SourceDocument } from '../adapter.js';
+import { SourceAsset, SourceSection, SourceTextStream } from '../types.js';
+import { EpubArchive } from './archive.js';
+import { EpubContentLoader } from './content.js';
+import { EpubPackageData } from './package.js';
+import '../meta.js';
+import 'zod';
+import 'stream';
+import 'yauzl';
+
+interface SectionDefinition {
+    readonly hasContent: boolean;
+    readonly id: string;
+    readonly title: string | undefined;
+    readonly path: string | undefined;
+    readonly fragment: string | undefined;
+    readonly wordsCount: number;
+    readonly children: readonly SectionDefinition[];
+}
+declare class EpubSourceSection implements SourceSection {
+    #private;
+    constructor(document: EpubSourceDocument, definition: SectionDefinition);
+    get id(): string;
+    get hasContent(): boolean;
+    get title(): string | undefined;
+    get wordsCount(): number;
+    get children(): readonly SourceSection[];
+    open(): Promise<SourceTextStream>;
+}
+declare class EpubSourceDocument implements SourceDocument {
+    #private;
+    constructor(packageData: EpubPackageData, cover: SourceAsset | undefined, sections: readonly SectionDefinition[], contentLoader: EpubContentLoader);
+    static open(archive: EpubArchive): Promise<EpubSourceDocument>;
+    readMeta(): Promise<{
+        version: 1;
+        sourceFormat: "epub" | "pdf" | "txt" | "markdown";
+        title: string | null;
+        authors: string[];
+        language: string | null;
+        identifier: string | null;
+        publisher: string | null;
+        publishedAt: string | null;
+        description: string | null;
+    }>;
+    readCover(): Promise<SourceAsset | undefined>;
+    readSections(): Promise<EpubSourceSection[]>;
+    openSection(sectionId: string): Promise<SourceTextStream>;
+}
+declare class EpubSourceAdapter implements SourceAdapter {
+    get format(): "epub";
+    openSession<T>(path: string, operation: (document: SourceDocument) => Promise<T>): Promise<T>;
+}
+declare const EPUB_SOURCE_ADAPTER: EpubSourceAdapter;
+
+export { EPUB_SOURCE_ADAPTER, EpubSourceAdapter, EpubSourceDocument };

package/dist/source/epub/document.js

@@ -0,0 +1,179 @@
+import { normalizeFragment } from "./archive.js";
+import { EpubArchive } from "./archive.js";
+import {
+  analyzeSectionTargets,
+  EpubContentLoader
+} from "./content.js";
+import { readEpubNavigation } from "./navigation.js";
+import { readEpubPackage } from "./package.js";
+class EpubSourceSection {
+  #document;
+  #definition;
+  constructor(document, definition) {
+    this.#document = document;
+    this.#definition = definition;
+  }
+  get id() {
+    return this.#definition.id;
+  }
+  get hasContent() {
+    return this.#definition.hasContent;
+  }
+  get title() {
+    return this.#definition.title;
+  }
+  get wordsCount() {
+    return this.#definition.wordsCount;
+  }
+  get children() {
+    return this.#definition.children.map(
+      (child) => new EpubSourceSection(this.#document, child)
+    );
+  }
+  async open() {
+    return await this.#document.openSection(this.#definition.id);
+  }
+}
+class EpubSourceDocument {
+  #packageData;
+  #cover;
+  #sections;
+  #contentLoader;
+  constructor(packageData, cover, sections, contentLoader) {
+    this.#packageData = packageData;
+    this.#cover = cover;
+    this.#sections = sections;
+    this.#contentLoader = contentLoader;
+  }
+  static async open(archive) {
+    assertArchiveIsSupported(archive);
+    const packageData = await readEpubPackage(archive);
+    const navigation = await readEpubNavigation(archive, packageData);
+    const rawSections = buildSections(archive, navigation);
+    const targetsByPath = groupTargetsByPath(rawSections);
+    const sectionAnalyses = await analyzeSectionTargets(archive, targetsByPath);
+    const sections = hydrateSectionAnalyses(rawSections, sectionAnalyses);
+    const cover = await readCoverAsset(archive, packageData);
+    return new EpubSourceDocument(
+      packageData,
+      cover,
+      sections,
+      new EpubContentLoader(archive, targetsByPath)
+    );
+  }
+  readMeta() {
+    return Promise.resolve(this.#packageData.metadata);
+  }
+  readCover() {
+    return Promise.resolve(this.#cover);
+  }
+  readSections() {
+    return Promise.resolve(
+      this.#sections.map((section) => new EpubSourceSection(this, section))
+    );
+  }
+  async openSection(sectionId) {
+    return await this.#contentLoader.openSection(sectionId);
+  }
+}
+class EpubSourceAdapter {
+  get format() {
+    return "epub";
+  }
+  async openSession(path, operation) {
+    const archive = await EpubArchive.open(path);
+    try {
+      const document = await EpubSourceDocument.open(archive);
+      return await operation(document);
+    } finally {
+      await archive.close();
+    }
+  }
+}
+const EPUB_SOURCE_ADAPTER = new EpubSourceAdapter();
+function assertArchiveIsSupported(archive) {
+  if (!archive.hasEntry("META-INF/encryption.xml")) {
+    return;
+  }
+  throw new Error(
+    "Encrypted EPUB is not supported: found META-INF/encryption.xml."
+  );
+}
+async function readCoverAsset(archive, packageData) {
+  if (packageData.coverPath === void 0 || packageData.coverMediaType === void 0) {
+    return void 0;
+  }
+  return {
+    path: packageData.coverPath,
+    mediaType: packageData.coverMediaType,
+    data: await archive.readBuffer(packageData.coverPath)
+  };
+}
+function buildSections(archive, items) {
+  const idCounts = /* @__PURE__ */ new Map();
+  return items.map(
+    (item, index) => buildSection(archive, item, [index], idCounts)
+  );
+}
+function buildSection(archive, item, indexPath, idCounts) {
+  const fragment = normalizeFragment(item.fragment);
+  const baseId = item.path === void 0 ? `toc:${indexPath.join(".")}` : archive.createSectionId(item.path, fragment);
+  const id = createUniqueId(baseId, idCounts);
+  return {
+    hasContent: item.path !== void 0,
+    id,
+    title: item.title,
+    path: item.path,
+    fragment,
+    wordsCount: 0,
+    children: item.children.map(
+      (child, index) => buildSection(archive, child, [...indexPath, index], idCounts)
+    )
+  };
+}
+function hydrateSectionAnalyses(sections, sectionAnalyses) {
+  return sections.map((section) => {
+    const analysis = sectionAnalyses.get(section.id);
+    return {
+      ...section,
+      hasContent: analysis?.hasContent ?? false,
+      wordsCount: analysis?.wordsCount ?? 0,
+      children: hydrateSectionAnalyses(section.children, sectionAnalyses)
+    };
+  });
+}
+function createUniqueId(baseId, idCounts) {
+  const currentCount = idCounts.get(baseId) ?? 0;
+  idCounts.set(baseId, currentCount + 1);
+  return currentCount === 0 ? baseId : `${baseId}~${currentCount + 1}`;
+}
+function groupTargetsByPath(sections) {
+  const targetsByPath = /* @__PURE__ */ new Map();
+  for (const section of flattenSections(sections)) {
+    if (section.path === void 0) {
+      continue;
+    }
+    const targets = targetsByPath.get(section.path) ?? [];
+    targets.push({
+      id: section.id,
+      path: section.path,
+      fragment: section.fragment
+    });
+    targetsByPath.set(section.path, targets);
+  }
+  return targetsByPath;
+}
+function flattenSections(sections) {
+  const flattened = [];
+  for (const section of sections) {
+    flattened.push(section);
+    flattened.push(...flattenSections(section.children));
+  }
+  return flattened;
+}
+export {
+  EPUB_SOURCE_ADAPTER,
+  EpubSourceAdapter,
+  EpubSourceDocument
+};
+//# sourceMappingURL=document.js.map