wiki-graph-core 0.3.1

package/dist/source/epub/xml.js

@@ -0,0 +1,111 @@
+import { SaxesParser } from "saxes";
+function parseXml(content) {
+  const parser = new SaxesParser({ xmlns: false });
+  const stack = [];
+  let root;
+  parser.on("opentag", (tag) => {
+    const element = {
+      name: tag.name,
+      attributes: Object.fromEntries(
+        Object.entries(tag.attributes).map(([name, value]) => [
+          name,
+          String(value)
+        ])
+      ),
+      children: [],
+      text: ""
+    };
+    const parent = stack[stack.length - 1];
+    if (parent === void 0) {
+      root = element;
+    } else {
+      parent.children.push(element);
+    }
+    stack.push(element);
+  });
+  parser.on("text", (text) => {
+    const current = stack[stack.length - 1];
+    if (current !== void 0) {
+      current.text += text;
+    }
+  });
+  parser.on("cdata", (text) => {
+    const current = stack[stack.length - 1];
+    if (current !== void 0) {
+      current.text += text;
+    }
+  });
+  parser.on("closetag", () => {
+    stack.pop();
+  });
+  parser.write(content).close();
+  if (root === void 0) {
+    throw new Error("XML document is empty");
+  }
+  return freezeXmlElement(root);
+}
+function findChild(element, localName) {
+  return element.children.find(
+    (child) => getLocalName(child.name) === localName
+  );
+}
+function findChildren(element, localName) {
+  return element.children.filter(
+    (child) => getLocalName(child.name) === localName
+  );
+}
+function findDescendant(element, localName) {
+  for (const child of element.children) {
+    if (getLocalName(child.name) === localName) {
+      return child;
+    }
+    const descendant = findDescendant(child, localName);
+    if (descendant !== void 0) {
+      return descendant;
+    }
+  }
+  return void 0;
+}
+function findDescendants(element, localName) {
+  const descendants = [];
+  for (const child of element.children) {
+    if (getLocalName(child.name) === localName) {
+      descendants.push(child);
+    }
+    descendants.push(...findDescendants(child, localName));
+  }
+  return descendants;
+}
+function getAttribute(element, name) {
+  return element.attributes[name];
+}
+function getDescendantText(element) {
+  let text = element.text;
+  for (const child of element.children) {
+    text += getDescendantText(child);
+  }
+  return text;
+}
+function getLocalName(name) {
+  const index = name.indexOf(":");
+  return index === -1 ? name : name.slice(index + 1);
+}
+function freezeXmlElement(element) {
+  return {
+    name: element.name,
+    attributes: Object.freeze({ ...element.attributes }),
+    children: Object.freeze(element.children.map(freezeXmlElement)),
+    text: element.text
+  };
+}
+export {
+  findChild,
+  findChildren,
+  findDescendant,
+  findDescendants,
+  getAttribute,
+  getDescendantText,
+  getLocalName,
+  parseXml
+};
+//# sourceMappingURL=xml.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/source/epub/xml.ts"],"sourcesContent":["import { SaxesParser, type SaxesTagPlain } from \"saxes\";\n\nexport interface XmlElement {\n  readonly name: string;\n  readonly attributes: Readonly<Record<string, string>>;\n  readonly children: readonly XmlElement[];\n  readonly text: string;\n}\n\ninterface MutableXmlElement {\n  readonly name: string;\n  readonly attributes: Record<string, string>;\n  readonly children: MutableXmlElement[];\n  text: string;\n}\n\nexport function parseXml(content: string): XmlElement {\n  const parser = new SaxesParser({ xmlns: false });\n  const stack: MutableXmlElement[] = [];\n  let root: MutableXmlElement | undefined;\n\n  parser.on(\"opentag\", (tag: SaxesTagPlain) => {\n    const element: MutableXmlElement = {\n      name: tag.name,\n      attributes: Object.fromEntries(\n        Object.entries(tag.attributes).map(([name, value]) => [\n          name,\n          String(value),\n        ]),\n      ),\n      children: [],\n      text: \"\",\n    };\n\n    const parent = stack[stack.length - 1];\n    if (parent === undefined) {\n      root = element;\n    } else {\n      parent.children.push(element);\n    }\n\n    stack.push(element);\n  });\n\n  parser.on(\"text\", (text: string) => {\n    const current = stack[stack.length - 1];\n    if (current !== undefined) {\n      current.text += text;\n    }\n  });\n\n  parser.on(\"cdata\", (text: string) => {\n    const current = stack[stack.length - 1];\n    if (current !== undefined) {\n      current.text += text;\n    }\n  });\n\n  parser.on(\"closetag\", () => {\n    stack.pop();\n  });\n\n  parser.write(content).close();\n\n  if (root === undefined) {\n    throw new Error(\"XML document is empty\");\n  }\n\n  return freezeXmlElement(root);\n}\n\nexport function findChild(\n  element: XmlElement,\n  localName: string,\n): XmlElement | undefined {\n  return element.children.find(\n    (child) => getLocalName(child.name) === localName,\n  );\n}\n\nexport function findChildren(\n  element: XmlElement,\n  localName: string,\n): readonly XmlElement[] {\n  return element.children.filter(\n    (child) => getLocalName(child.name) === localName,\n  );\n}\n\nexport function findDescendant(\n  element: XmlElement,\n  localName: string,\n): XmlElement | undefined {\n  for (const child of element.children) {\n    if (getLocalName(child.name) === localName) {\n      return child;\n    }\n\n    const descendant = findDescendant(child, localName);\n    if (descendant !== undefined) {\n      return descendant;\n    }\n  }\n\n  return undefined;\n}\n\nexport function findDescendants(\n  element: XmlElement,\n  localName: string,\n): readonly XmlElement[] {\n  const descendants: XmlElement[] = [];\n\n  for (const child of element.children) {\n    if (getLocalName(child.name) === localName) {\n      descendants.push(child);\n    }\n\n    descendants.push(...findDescendants(child, localName));\n  }\n\n  return descendants;\n}\n\nexport function getAttribute(\n  element: XmlElement,\n  name: string,\n): string | undefined {\n  return element.attributes[name];\n}\n\nexport function getDescendantText(element: XmlElement): string {\n  let text = element.text;\n\n  for (const child of element.children) {\n    text += getDescendantText(child);\n  }\n\n  return text;\n}\n\nexport function getLocalName(name: string): string {\n  const index = name.indexOf(\":\");\n\n  return index === -1 ? name : name.slice(index + 1);\n}\n\nfunction freezeXmlElement(element: MutableXmlElement): XmlElement {\n  return {\n    name: element.name,\n    attributes: Object.freeze({ ...element.attributes }),\n    children: Object.freeze(element.children.map(freezeXmlElement)),\n    text: element.text,\n  };\n}\n"],"mappings":"AAAA,SAAS,mBAAuC;AAgBzC,SAAS,SAAS,SAA6B;AACpD,QAAM,SAAS,IAAI,YAAY,EAAE,OAAO,MAAM,CAAC;AAC/C,QAAM,QAA6B,CAAC;AACpC,MAAI;AAEJ,SAAO,GAAG,WAAW,CAAC,QAAuB;AAC3C,UAAM,UAA6B;AAAA,MACjC,MAAM,IAAI;AAAA,MACV,YAAY,OAAO;AAAA,QACjB,OAAO,QAAQ,IAAI,UAAU,EAAE,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM;AAAA,UACpD;AAAA,UACA,OAAO,KAAK;AAAA,QACd,CAAC;AAAA,MACH;AAAA,MACA,UAAU,CAAC;AAAA,MACX,MAAM;AAAA,IACR;AAEA,UAAM,SAAS,MAAM,MAAM,SAAS,CAAC;AACrC,QAAI,WAAW,QAAW;AACxB,aAAO;AAAA,IACT,OAAO;AACL,aAAO,SAAS,KAAK,OAAO;AAAA,IAC9B;AAEA,UAAM,KAAK,OAAO;AAAA,EACpB,CAAC;AAED,SAAO,GAAG,QAAQ,CAAC,SAAiB;AAClC,UAAM,UAAU,MAAM,MAAM,SAAS,CAAC;AACtC,QAAI,YAAY,QAAW;AACzB,cAAQ,QAAQ;AAAA,IAClB;AAAA,EACF,CAAC;AAED,SAAO,GAAG,SAAS,CAAC,SAAiB;AACnC,UAAM,UAAU,MAAM,MAAM,SAAS,CAAC;AACtC,QAAI,YAAY,QAAW;AACzB,cAAQ,QAAQ;AAAA,IAClB;AAAA,EACF,CAAC;AAED,SAAO,GAAG,YAAY,MAAM;AAC1B,UAAM,IAAI;AAAA,EACZ,CAAC;AAED,SAAO,MAAM,OAAO,EAAE,MAAM;AAE5B,MAAI,SAAS,QAAW;AACtB,UAAM,IAAI,MAAM,uBAAuB;AAAA,EACzC;AAEA,SAAO,iBAAiB,IAAI;AAC9B;AAEO,SAAS,UACd,SACA,WACwB;AACxB,SAAO,QAAQ,SAAS;AAAA,IACtB,CAAC,UAAU,aAAa,MAAM,IAAI,MAAM;AAAA,EAC1C;AACF;AAEO,SAAS,aACd,SACA,WACuB;AACvB,SAAO,QAAQ,SAAS;AAAA,IACtB,CAAC,UAAU,aAAa,MAAM,IAAI,MAAM;AAAA,EAC1C;AACF;AAEO,SAAS,eACd,SACA,WACwB;AACxB,aAAW,SAAS,QAAQ,UAAU;AACpC,QAAI,aAAa,MAAM,IAAI,MAAM,WAAW;AAC1C,aAAO;AAAA,IACT;AAEA,UAAM,aAAa,eAAe,OAAO,SAAS;AAClD,QAAI,eAAe,QAAW;AAC5B,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AAEO,SAAS,gBACd,SACA,WACuB;AACvB,QAAM,cAA4B,CAAC;AAEnC,aAAW,SAAS,QAAQ,UAAU;AACpC,QAAI,aAAa,MAAM,IAAI,MAAM,WAAW;AAC1C,kBAAY,KAAK,KAAK;AAAA,IACxB;AAEA,gBAAY,KAAK,GAAG,gBAAgB,OAAO,SAAS,CAAC;AAAA,EACvD;AAEA,SAAO;AACT;AAEO,SAAS,aACd,SACA,MACoB;AACpB,SAAO,QAAQ,WAAW,IAAI;AAChC;AAEO,SAAS,kBAAkB,SAA6B;AAC7D,MAAI,OAAO,QAAQ;AAEnB,aAAW,SAAS,QAAQ,UAAU;AACpC,YAAQ,kBAAkB,KAAK;AAAA,EACjC;AAEA,SAAO;AACT;AAEO,SAAS,aAAa,MAAsB;AACjD,QAAM,QAAQ,KAAK,QAAQ,GAAG;AAE9B,SAAO,UAAU,KAAK,OAAO,KAAK,MAAM,QAAQ,CAAC;AACnD;AAEA,SAAS,iBAAiB,SAAwC;AAChE,SAAO;AAAA,IACL,MAAM,QAAQ;AAAA,IACd,YAAY,OAAO,OAAO,EAAE,GAAG,QAAQ,WAAW,CAAC;AAAA,IACnD,UAAU,OAAO,OAAO,QAAQ,SAAS,IAAI,gBAAgB,CAAC;AAAA,IAC9D,MAAM,QAAQ;AAAA,EAChB;AACF;","names":[]}

package/dist/source/index.d.ts

@@ -0,0 +1,12 @@
+export { BOOK_META_VERSION, BookMeta, SOURCE_FORMATS, SourceFormat, bookMetaSchema, sourceFormatSchema } from './meta.js';
+export { SourceAdapter, SourceDocument } from './adapter.js';
+export { EPUB_SOURCE_ADAPTER, EpubSourceAdapter } from './epub/document.js';
+export { MARKDOWN_SOURCE_ADAPTER, PlainTextSourceAdapter, TXT_SOURCE_ADAPTER } from './plain-text.js';
+export { TOC_FILE_VERSION, TocFile, TocItem, tocFileSchema, tocItemSchema } from './toc.js';
+export { SourceAsset, SourceSection, SourceTextStream } from './types.js';
+import 'zod';
+import './epub/archive.js';
+import 'stream';
+import 'yauzl';
+import './epub/content.js';
+import './epub/package.js';

package/dist/source/index.js

@@ -0,0 +1,32 @@
+import {
+  BOOK_META_VERSION,
+  SOURCE_FORMATS,
+  bookMetaSchema,
+  sourceFormatSchema
+} from "./meta.js";
+import { EpubSourceAdapter, EPUB_SOURCE_ADAPTER } from "./epub/index.js";
+import {
+  MARKDOWN_SOURCE_ADAPTER,
+  PlainTextSourceAdapter,
+  TXT_SOURCE_ADAPTER
+} from "./plain-text.js";
+import {
+  TOC_FILE_VERSION,
+  tocFileSchema,
+  tocItemSchema
+} from "./toc.js";
+export {
+  BOOK_META_VERSION,
+  EPUB_SOURCE_ADAPTER,
+  EpubSourceAdapter,
+  MARKDOWN_SOURCE_ADAPTER,
+  PlainTextSourceAdapter,
+  SOURCE_FORMATS,
+  TOC_FILE_VERSION,
+  TXT_SOURCE_ADAPTER,
+  bookMetaSchema,
+  sourceFormatSchema,
+  tocFileSchema,
+  tocItemSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/source/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/source/index.ts"],"sourcesContent":["export {\n  BOOK_META_VERSION,\n  SOURCE_FORMATS,\n  bookMetaSchema,\n  sourceFormatSchema,\n  type BookMeta,\n  type SourceFormat,\n} from \"./meta.js\";\nexport type { SourceAdapter, SourceDocument } from \"./adapter.js\";\nexport { EpubSourceAdapter, EPUB_SOURCE_ADAPTER } from \"./epub/index.js\";\nexport {\n  MARKDOWN_SOURCE_ADAPTER,\n  PlainTextSourceAdapter,\n  TXT_SOURCE_ADAPTER,\n} from \"./plain-text.js\";\nexport {\n  TOC_FILE_VERSION,\n  tocFileSchema,\n  tocItemSchema,\n  type TocFile,\n  type TocItem,\n} from \"./toc.js\";\nexport type { SourceAsset, SourceSection, SourceTextStream } from \"./types.js\";\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AAEP,SAAS,mBAAmB,2BAA2B;AACvD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;","names":[]}

package/dist/source/meta.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+declare const SOURCE_FORMATS: readonly ["epub", "pdf", "txt", "markdown"];
+declare const BOOK_META_VERSION = 1;
+declare const sourceFormatSchema: z.ZodEnum<{
+    epub: "epub";
+    pdf: "pdf";
+    txt: "txt";
+    markdown: "markdown";
+}>;
+declare const bookMetaSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    sourceFormat: z.ZodEnum<{
+        epub: "epub";
+        pdf: "pdf";
+        txt: "txt";
+        markdown: "markdown";
+    }>;
+    title: z.ZodNullable<z.ZodString>;
+    authors: z.ZodArray<z.ZodString>;
+    language: z.ZodNullable<z.ZodString>;
+    identifier: z.ZodNullable<z.ZodString>;
+    publisher: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type SourceFormat = z.infer<typeof sourceFormatSchema>;
+type BookMeta = z.infer<typeof bookMetaSchema>;
+
+export { BOOK_META_VERSION, type BookMeta, SOURCE_FORMATS, type SourceFormat, bookMetaSchema, sourceFormatSchema };

package/dist/source/meta.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+const SOURCE_FORMATS = ["epub", "pdf", "txt", "markdown"];
+const BOOK_META_VERSION = 1;
+const sourceFormatSchema = z.enum(SOURCE_FORMATS);
+const bookMetaSchema = z.object({
+  version: z.literal(BOOK_META_VERSION),
+  sourceFormat: sourceFormatSchema,
+  title: z.string().min(1).nullable(),
+  authors: z.array(z.string().min(1)),
+  language: z.string().min(1).nullable(),
+  identifier: z.string().min(1).nullable(),
+  publisher: z.string().min(1).nullable(),
+  publishedAt: z.string().min(1).nullable(),
+  description: z.string().min(1).nullable()
+});
+export {
+  BOOK_META_VERSION,
+  SOURCE_FORMATS,
+  bookMetaSchema,
+  sourceFormatSchema
+};
+//# sourceMappingURL=meta.js.map

package/dist/source/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/source/meta.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const SOURCE_FORMATS = [\"epub\", \"pdf\", \"txt\", \"markdown\"] as const;\nexport const BOOK_META_VERSION = 1;\n\nexport const sourceFormatSchema = z.enum(SOURCE_FORMATS);\n\nexport const bookMetaSchema = z.object({\n  version: z.literal(BOOK_META_VERSION),\n  sourceFormat: sourceFormatSchema,\n  title: z.string().min(1).nullable(),\n  authors: z.array(z.string().min(1)),\n  language: z.string().min(1).nullable(),\n  identifier: z.string().min(1).nullable(),\n  publisher: z.string().min(1).nullable(),\n  publishedAt: z.string().min(1).nullable(),\n  description: z.string().min(1).nullable(),\n});\n\nexport type SourceFormat = z.infer<typeof sourceFormatSchema>;\nexport type BookMeta = z.infer<typeof bookMetaSchema>;\n"],"mappings":"AAAA,SAAS,SAAS;AAEX,MAAM,iBAAiB,CAAC,QAAQ,OAAO,OAAO,UAAU;AACxD,MAAM,oBAAoB;AAE1B,MAAM,qBAAqB,EAAE,KAAK,cAAc;AAEhD,MAAM,iBAAiB,EAAE,OAAO;AAAA,EACrC,SAAS,EAAE,QAAQ,iBAAiB;AAAA,EACpC,cAAc;AAAA,EACd,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EAClC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;AAAA,EAClC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EACrC,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EACvC,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EACtC,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EACxC,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAC1C,CAAC;","names":[]}

package/dist/source/plain-text.d.ts

@@ -0,0 +1,16 @@
+import { SourceAdapter, SourceDocument } from './adapter.js';
+import './meta.js';
+import 'zod';
+import './types.js';
+
+type PlainTextSourceFormat = "markdown" | "txt";
+declare class PlainTextSourceAdapter implements SourceAdapter {
+    #private;
+    constructor(format: PlainTextSourceFormat);
+    get format(): PlainTextSourceFormat;
+    openSession<T>(path: string, operation: (document: SourceDocument) => Promise<T>): Promise<T>;
+}
+declare const TXT_SOURCE_ADAPTER: PlainTextSourceAdapter;
+declare const MARKDOWN_SOURCE_ADAPTER: PlainTextSourceAdapter;
+
+export { MARKDOWN_SOURCE_ADAPTER, PlainTextSourceAdapter, TXT_SOURCE_ADAPTER };

package/dist/source/plain-text.js

@@ -0,0 +1,86 @@
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { basename, extname, resolve } from "path";
+import { BOOK_META_VERSION } from "./meta.js";
+const ROOT_SECTION_ID = "root";
+class PlainTextSection {
+  #path;
+  #id;
+  constructor(path, id = ROOT_SECTION_ID) {
+    this.#path = resolve(path);
+    this.#id = id;
+  }
+  get id() {
+    return this.#id;
+  }
+  get hasContent() {
+    return true;
+  }
+  get title() {
+    return void 0;
+  }
+  get children() {
+    return [];
+  }
+  open() {
+    return Promise.resolve(createReadStream(this.#path, { encoding: "utf8" }));
+  }
+}
+class PlainTextDocument {
+  #path;
+  #format;
+  #section;
+  constructor(path, format) {
+    this.#path = resolve(path);
+    this.#format = format;
+    this.#section = new PlainTextSection(this.#path);
+  }
+  readMeta() {
+    return Promise.resolve({
+      version: BOOK_META_VERSION,
+      sourceFormat: this.#format,
+      title: getFileStem(this.#path),
+      authors: [],
+      language: null,
+      identifier: null,
+      publisher: null,
+      publishedAt: null,
+      description: null
+    });
+  }
+  readCover() {
+    return Promise.resolve(void 0);
+  }
+  readSections() {
+    return Promise.resolve([this.#section]);
+  }
+}
+class PlainTextSourceAdapter {
+  #format;
+  constructor(format) {
+    this.#format = format;
+  }
+  get format() {
+    return this.#format;
+  }
+  async openSession(path, operation) {
+    const resolvedPath = resolve(path);
+    const fileStat = await stat(resolvedPath);
+    if (!fileStat.isFile()) {
+      throw new Error(`Source file is not a regular file: ${resolvedPath}`);
+    }
+    return await operation(new PlainTextDocument(resolvedPath, this.#format));
+  }
+}
+const TXT_SOURCE_ADAPTER = new PlainTextSourceAdapter("txt");
+const MARKDOWN_SOURCE_ADAPTER = new PlainTextSourceAdapter("markdown");
+function getFileStem(path) {
+  const stem = basename(path, extname(path)).trim();
+  return stem === "" ? null : stem;
+}
+export {
+  MARKDOWN_SOURCE_ADAPTER,
+  PlainTextSourceAdapter,
+  TXT_SOURCE_ADAPTER
+};
+//# sourceMappingURL=plain-text.js.map

package/dist/source/plain-text.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/source/plain-text.ts"],"sourcesContent":["import { createReadStream } from \"fs\";\nimport { stat } from \"fs/promises\";\nimport { basename, extname, resolve } from \"path\";\n\nimport { BOOK_META_VERSION, type BookMeta } from \"./meta.js\";\nimport type { SourceAdapter, SourceDocument } from \"./adapter.js\";\nimport type { SourceAsset, SourceSection, SourceTextStream } from \"./types.js\";\n\ntype PlainTextSourceFormat = \"markdown\" | \"txt\";\n\nconst ROOT_SECTION_ID = \"root\";\n\nclass PlainTextSection implements SourceSection {\n  readonly #path: string;\n  readonly #id: string;\n\n  public constructor(path: string, id = ROOT_SECTION_ID) {\n    this.#path = resolve(path);\n    this.#id = id;\n  }\n\n  public get id(): string {\n    return this.#id;\n  }\n\n  public get hasContent(): boolean {\n    return true;\n  }\n\n  public get title(): string | undefined {\n    return undefined;\n  }\n\n  public get children(): readonly SourceSection[] {\n    return [];\n  }\n\n  public open(): Promise<SourceTextStream> {\n    return Promise.resolve(createReadStream(this.#path, { encoding: \"utf8\" }));\n  }\n}\n\nclass PlainTextDocument implements SourceDocument {\n  readonly #path: string;\n  readonly #format: PlainTextSourceFormat;\n  readonly #section: PlainTextSection;\n\n  public constructor(path: string, format: PlainTextSourceFormat) {\n    this.#path = resolve(path);\n    this.#format = format;\n    this.#section = new PlainTextSection(this.#path);\n  }\n\n  public readMeta(): Promise<BookMeta> {\n    return Promise.resolve({\n      version: BOOK_META_VERSION,\n      sourceFormat: this.#format,\n      title: getFileStem(this.#path),\n      authors: [],\n      language: null,\n      identifier: null,\n      publisher: null,\n      publishedAt: null,\n      description: null,\n    });\n  }\n\n  public readCover(): Promise<SourceAsset | undefined> {\n    return Promise.resolve(undefined);\n  }\n\n  public readSections(): Promise<readonly SourceSection[]> {\n    return Promise.resolve([this.#section]);\n  }\n}\n\nexport class PlainTextSourceAdapter implements SourceAdapter {\n  readonly #format: PlainTextSourceFormat;\n\n  public constructor(format: PlainTextSourceFormat) {\n    this.#format = format;\n  }\n\n  public get format(): PlainTextSourceFormat {\n    return this.#format;\n  }\n\n  public async openSession<T>(\n    path: string,\n    operation: (document: SourceDocument) => Promise<T>,\n  ): Promise<T> {\n    const resolvedPath = resolve(path);\n    const fileStat = await stat(resolvedPath);\n\n    if (!fileStat.isFile()) {\n      throw new Error(`Source file is not a regular file: ${resolvedPath}`);\n    }\n\n    return await operation(new PlainTextDocument(resolvedPath, this.#format));\n  }\n}\n\nexport const TXT_SOURCE_ADAPTER = new PlainTextSourceAdapter(\"txt\");\nexport const MARKDOWN_SOURCE_ADAPTER = new PlainTextSourceAdapter(\"markdown\");\n\nfunction getFileStem(path: string): string | null {\n  const stem = basename(path, extname(path)).trim();\n\n  return stem === \"\" ? null : stem;\n}\n"],"mappings":"AAAA,SAAS,wBAAwB;AACjC,SAAS,YAAY;AACrB,SAAS,UAAU,SAAS,eAAe;AAE3C,SAAS,yBAAwC;AAMjD,MAAM,kBAAkB;AAExB,MAAM,iBAA0C;AAAA,EACrC;AAAA,EACA;AAAA,EAEF,YAAY,MAAc,KAAK,iBAAiB;AACrD,SAAK,QAAQ,QAAQ,IAAI;AACzB,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,IAAW,KAAa;AACtB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAW,aAAsB;AAC/B,WAAO;AAAA,EACT;AAAA,EAEA,IAAW,QAA4B;AACrC,WAAO;AAAA,EACT;AAAA,EAEA,IAAW,WAAqC;AAC9C,WAAO,CAAC;AAAA,EACV;AAAA,EAEO,OAAkC;AACvC,WAAO,QAAQ,QAAQ,iBAAiB,KAAK,OAAO,EAAE,UAAU,OAAO,CAAC,CAAC;AAAA,EAC3E;AACF;AAEA,MAAM,kBAA4C;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AAAA,EAEF,YAAY,MAAc,QAA+B;AAC9D,SAAK,QAAQ,QAAQ,IAAI;AACzB,SAAK,UAAU;AACf,SAAK,WAAW,IAAI,iBAAiB,KAAK,KAAK;AAAA,EACjD;AAAA,EAEO,WAA8B;AACnC,WAAO,QAAQ,QAAQ;AAAA,MACrB,SAAS;AAAA,MACT,cAAc,KAAK;AAAA,MACnB,OAAO,YAAY,KAAK,KAAK;AAAA,MAC7B,SAAS,CAAC;AAAA,MACV,UAAU;AAAA,MACV,YAAY;AAAA,MACZ,WAAW;AAAA,MACX,aAAa;AAAA,MACb,aAAa;AAAA,IACf,CAAC;AAAA,EACH;AAAA,EAEO,YAA8C;AACnD,WAAO,QAAQ,QAAQ,MAAS;AAAA,EAClC;AAAA,EAEO,eAAkD;AACvD,WAAO,QAAQ,QAAQ,CAAC,KAAK,QAAQ,CAAC;AAAA,EACxC;AACF;AAEO,MAAM,uBAAgD;AAAA,EAClD;AAAA,EAEF,YAAY,QAA+B;AAChD,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,IAAW,SAAgC;AACzC,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAa,YACX,MACA,WACY;AACZ,UAAM,eAAe,QAAQ,IAAI;AACjC,UAAM,WAAW,MAAM,KAAK,YAAY;AAExC,QAAI,CAAC,SAAS,OAAO,GAAG;AACtB,YAAM,IAAI,MAAM,sCAAsC,YAAY,EAAE;AAAA,IACtE;AAEA,WAAO,MAAM,UAAU,IAAI,kBAAkB,cAAc,KAAK,OAAO,CAAC;AAAA,EAC1E;AACF;AAEO,MAAM,qBAAqB,IAAI,uBAAuB,KAAK;AAC3D,MAAM,0BAA0B,IAAI,uBAAuB,UAAU;AAE5E,SAAS,YAAY,MAA6B;AAChD,QAAM,OAAO,SAAS,MAAM,QAAQ,IAAI,CAAC,EAAE,KAAK;AAEhD,SAAO,SAAS,KAAK,OAAO;AAC9B;","names":[]}

package/dist/source/toc.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+declare const TOC_FILE_VERSION = 1;
+interface TocItem {
+    readonly title?: string | null | undefined;
+    readonly serialId?: number | undefined;
+    readonly children: readonly TocItem[];
+}
+declare const tocItemSchema: z.ZodType<TocItem>;
+declare const tocFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    items: z.ZodArray<z.ZodType<TocItem, unknown, z.core.$ZodTypeInternals<TocItem, unknown>>>;
+}, z.core.$strip>;
+type TocFile = z.infer<typeof tocFileSchema>;
+
+export { TOC_FILE_VERSION, type TocFile, type TocItem, tocFileSchema, tocItemSchema };

package/dist/source/toc.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+const TOC_FILE_VERSION = 1;
+const tocItemSchema = z.object({
+  title: z.string().min(1).nullable().optional(),
+  serialId: z.number().int().nonnegative().optional(),
+  children: z.lazy(() => z.array(tocItemSchema))
+});
+const tocFileSchema = z.object({
+  version: z.literal(TOC_FILE_VERSION),
+  items: z.array(tocItemSchema)
+});
+export {
+  TOC_FILE_VERSION,
+  tocFileSchema,
+  tocItemSchema
+};
+//# sourceMappingURL=toc.js.map

package/dist/source/toc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/source/toc.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const TOC_FILE_VERSION = 1;\n\nexport interface TocItem {\n  readonly title?: string | null | undefined;\n  readonly serialId?: number | undefined;\n  readonly children: readonly TocItem[];\n}\n\nexport const tocItemSchema: z.ZodType<TocItem> = z.object({\n  title: z.string().min(1).nullable().optional(),\n  serialId: z.number().int().nonnegative().optional(),\n  children: z.lazy(() => z.array(tocItemSchema)),\n});\n\nexport const tocFileSchema = z.object({\n  version: z.literal(TOC_FILE_VERSION),\n  items: z.array(tocItemSchema),\n});\n\nexport type TocFile = z.infer<typeof tocFileSchema>;\n"],"mappings":"AAAA,SAAS,SAAS;AAEX,MAAM,mBAAmB;AAQzB,MAAM,gBAAoC,EAAE,OAAO;AAAA,EACxD,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS;AAAA,EAC7C,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS;AAAA,EAClD,UAAU,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAC/C,CAAC;AAEM,MAAM,gBAAgB,EAAE,OAAO;AAAA,EACpC,SAAS,EAAE,QAAQ,gBAAgB;AAAA,EACnC,OAAO,EAAE,MAAM,aAAa;AAC9B,CAAC;","names":[]}

package/dist/source/types.d.ts

@@ -0,0 +1,16 @@
+type SourceTextStream = AsyncIterable<string> | Iterable<string>;
+interface SourceAsset {
+    readonly path: string;
+    readonly mediaType: string;
+    readonly data: Uint8Array;
+}
+interface SourceSection {
+    readonly hasContent: boolean;
+    readonly id: string;
+    readonly title?: string | undefined;
+    readonly wordsCount?: number | undefined;
+    readonly children: readonly SourceSection[];
+    open(): Promise<SourceTextStream>;
+}
+
+export type { SourceAsset, SourceSection, SourceTextStream };

package/dist/source/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/source/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/topology/grouping.d.ts

@@ -0,0 +1,15 @@
+import { SentenceGroupRecord } from '../document/types.js';
+import { computeNormalizedSegmentIncisions } from './segment-incision.js';
+import '../document/text-streams.js';
+import '../document/database.js';
+import 'sqlite3';
+
+declare function groupSegments(input: {
+    edges: Parameters<typeof computeNormalizedSegmentIncisions>[0]["edges"];
+    fragments: Parameters<typeof computeNormalizedSegmentIncisions>[0]["fragments"];
+    groupWordsCount: number;
+    chunks: Parameters<typeof computeNormalizedSegmentIncisions>[0]["chunks"];
+    serialId: number;
+}): Promise<SentenceGroupRecord[]>;
+
+export { groupSegments };

package/dist/topology/grouping.js

@@ -0,0 +1,18 @@
+import { computeNormalizedSegmentIncisions } from "./segment-incision.js";
+import { createSegmentGroups } from "./resource-segmentation.js";
+async function groupSegments(input) {
+  const segmentInfos = await computeNormalizedSegmentIncisions({
+    chunks: input.chunks,
+    edges: input.edges,
+    fragments: input.fragments
+  });
+  return createSegmentGroups({
+    segmentInfos,
+    groupWordsCount: input.groupWordsCount,
+    serialId: input.serialId
+  });
+}
+export {
+  groupSegments
+};
+//# sourceMappingURL=grouping.js.map

package/dist/topology/grouping.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/topology/grouping.ts"],"sourcesContent":["import type { SentenceGroupRecord } from \"../document/index.js\";\nimport { computeNormalizedSegmentIncisions } from \"./segment-incision.js\";\nimport { createSegmentGroups } from \"./resource-segmentation.js\";\n\nexport async function groupSegments(input: {\n  edges: Parameters<typeof computeNormalizedSegmentIncisions>[0][\"edges\"];\n  fragments: Parameters<\n    typeof computeNormalizedSegmentIncisions\n  >[0][\"fragments\"];\n  groupWordsCount: number;\n  chunks: Parameters<typeof computeNormalizedSegmentIncisions>[0][\"chunks\"];\n  serialId: number;\n}): Promise<SentenceGroupRecord[]> {\n  const segmentInfos = await computeNormalizedSegmentIncisions({\n    chunks: input.chunks,\n    edges: input.edges,\n    fragments: input.fragments,\n  });\n\n  return createSegmentGroups({\n    segmentInfos,\n    groupWordsCount: input.groupWordsCount,\n    serialId: input.serialId,\n  });\n}\n"],"mappings":"AACA,SAAS,yCAAyC;AAClD,SAAS,2BAA2B;AAEpC,eAAsB,cAAc,OAQD;AACjC,QAAM,eAAe,MAAM,kCAAkC;AAAA,IAC3D,QAAQ,MAAM;AAAA,IACd,OAAO,MAAM;AAAA,IACb,WAAW,MAAM;AAAA,EACnB,CAAC;AAED,SAAO,oBAAoB;AAAA,IACzB;AAAA,IACA,iBAAiB,MAAM;AAAA,IACvB,UAAU,MAAM;AAAA,EAClB,CAAC;AACH;","names":[]}

package/dist/topology/index.d.ts

@@ -0,0 +1,21 @@
+export { Topology } from './topology.js';
+import '../document/document.js';
+import '../source/meta.js';
+import 'zod';
+import '../source/toc.js';
+import '../source/types.js';
+import '../document/database.js';
+import 'sqlite3';
+import '../document/text-streams.js';
+import '../document/types.js';
+import '../document/stores.js';
+import '../reader/types.js';
+import '../reader/attention/attention.js';
+import '../reader/chunk-batch/types.js';
+import '../common/language.js';
+import '../llm/client.js';
+import '../llm/context.js';
+import '../llm/cache.js';
+import '../llm/types.js';
+import 'ai';
+import '../reader/segment/types.js';

package/dist/topology/index.js

@@ -0,0 +1,5 @@
+import { Topology } from "./topology.js";
+export {
+  Topology
+};
+//# sourceMappingURL=index.js.map

package/dist/topology/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/topology/index.ts"],"sourcesContent":["export { Topology } from \"./topology.js\";\n"],"mappings":"AAAA,SAAS,gBAAgB;","names":[]}

package/dist/topology/resource-segmentation.d.ts

@@ -0,0 +1,13 @@
+import { SentenceGroupRecord } from '../document/types.js';
+import { SegmentInfo } from './segment-incision.js';
+import '../document/text-streams.js';
+import '../document/database.js';
+import 'sqlite3';
+
+declare function createSegmentGroups(input: {
+    segmentInfos: readonly SegmentInfo[];
+    groupWordsCount: number;
+    serialId: number;
+}): SentenceGroupRecord[];
+
+export { createSegmentGroups };

package/dist/topology/resource-segmentation.js

@@ -0,0 +1,111 @@
+function createSegmentGroups(input) {
+  if (input.segmentInfos.length === 0) {
+    return [];
+  }
+  const resources = input.segmentInfos.map(
+    (segmentInfo) => ({
+      count: segmentInfo.wordsCount,
+      endIncision: segmentInfo.endIncision,
+      startSentenceIndex: segmentInfo.startSentenceIndex,
+      startIncision: segmentInfo.startIncision
+    })
+  );
+  const groups = allocateSegmentGroups(resources, input.groupWordsCount);
+  return groups.map((startSentenceIndexes, groupId) => ({
+    endSentenceIndex: Math.max(...startSentenceIndexes),
+    groupId,
+    serialId: input.serialId,
+    startSentenceIndex: Math.min(...startSentenceIndexes)
+  }));
+}
+function allocateSegmentGroups(resources, maxCount) {
+  return splitResources(resources, maxCount).map(
+    (group) => group.map((resource) => resource.startSentenceIndex)
+  );
+}
+function splitResources(resources, maxCount) {
+  if (resources.length === 0) {
+    return [];
+  }
+  if (maxCount <= 0) {
+    return resources.map((resource) => [resource]);
+  }
+  const totalCount = resources.reduce((total, resource) => {
+    return total + resource.count;
+  }, 0);
+  if (resources.length === 1 || totalCount <= maxCount) {
+    return [[...resources]];
+  }
+  const splitIndex = findPreferredSplitIndex(resources, maxCount);
+  if (splitIndex === void 0) {
+    return splitGreedily(resources, maxCount);
+  }
+  const left = resources.slice(0, splitIndex + 1);
+  const right = resources.slice(splitIndex + 1);
+  if (left.length === 0 || right.length === 0 || left.length === resources.length || right.length === resources.length) {
+    return splitGreedily(resources, maxCount);
+  }
+  return [
+    ...splitResources(left, maxCount),
+    ...splitResources(right, maxCount)
+  ];
+}
+function findPreferredSplitIndex(resources, maxCount) {
+  const totalCount = resources.reduce((total, resource) => {
+    return total + resource.count;
+  }, 0);
+  let leftCount = 0;
+  let bestIndex;
+  let bestBoundary = 0;
+  let bestOversizedSides = Number.POSITIVE_INFINITY;
+  let bestOverflow = Number.POSITIVE_INFINITY;
+  for (let index = 0; index < resources.length - 1; index += 1) {
+    const current = resources[index];
+    const next = resources[index + 1];
+    if (current === void 0 || next === void 0) {
+      continue;
+    }
+    leftCount += current.count;
+    const rightCount = totalCount - leftCount;
+    const boundary = current.endIncision + next.startIncision;
+    if (boundary <= 0) {
+      continue;
+    }
+    const oversizedSides = Number(leftCount > maxCount) + Number(rightCount > maxCount);
+    const overflow = Math.max(0, leftCount - maxCount) + Math.max(0, rightCount - maxCount);
+    if (oversizedSides < bestOversizedSides || oversizedSides === bestOversizedSides && boundary > bestBoundary || oversizedSides === bestOversizedSides && boundary === bestBoundary && overflow < bestOverflow) {
+      bestBoundary = boundary;
+      bestIndex = index;
+      bestOversizedSides = oversizedSides;
+      bestOverflow = overflow;
+    }
+  }
+  return bestIndex;
+}
+function splitGreedily(resources, maxCount) {
+  const groups = [];
+  let currentGroup = [];
+  let currentCount = 0;
+  for (const resource of resources) {
+    if (currentGroup.length > 0 && currentCount + resource.count > maxCount) {
+      groups.push(currentGroup);
+      currentGroup = [];
+      currentCount = 0;
+    }
+    currentGroup.push(resource);
+    currentCount += resource.count;
+    if (currentCount >= maxCount) {
+      groups.push(currentGroup);
+      currentGroup = [];
+      currentCount = 0;
+    }
+  }
+  if (currentGroup.length > 0) {
+    groups.push(currentGroup);
+  }
+  return groups;
+}
+export {
+  createSegmentGroups
+};
+//# sourceMappingURL=resource-segmentation.js.map

package/dist/topology/resource-segmentation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/topology/resource-segmentation.ts"],"sourcesContent":["import type { SentenceGroupRecord } from \"../document/index.js\";\nimport type { SegmentInfo } from \"./segment-incision.js\";\n\ninterface SegmentResource {\n  readonly count: number;\n  readonly startIncision: number;\n  readonly endIncision: number;\n  readonly startSentenceIndex: number;\n}\n\nexport function createSegmentGroups(input: {\n  segmentInfos: readonly SegmentInfo[];\n  groupWordsCount: number;\n  serialId: number;\n}): SentenceGroupRecord[] {\n  if (input.segmentInfos.length === 0) {\n    return [];\n  }\n\n  const resources = input.segmentInfos.map(\n    (segmentInfo): SegmentResource => ({\n      count: segmentInfo.wordsCount,\n      endIncision: segmentInfo.endIncision,\n      startSentenceIndex: segmentInfo.startSentenceIndex,\n      startIncision: segmentInfo.startIncision,\n    }),\n  );\n  const groups = allocateSegmentGroups(resources, input.groupWordsCount);\n\n  return groups.map((startSentenceIndexes, groupId) => ({\n    endSentenceIndex: Math.max(...startSentenceIndexes),\n    groupId,\n    serialId: input.serialId,\n    startSentenceIndex: Math.min(...startSentenceIndexes),\n  }));\n}\n\nfunction allocateSegmentGroups(\n  resources: readonly SegmentResource[],\n  maxCount: number,\n): number[][] {\n  return splitResources(resources, maxCount).map((group) =>\n    group.map((resource) => resource.startSentenceIndex),\n  );\n}\n\nfunction splitResources(\n  resources: readonly SegmentResource[],\n  maxCount: number,\n): SegmentResource[][] {\n  if (resources.length === 0) {\n    return [];\n  }\n\n  if (maxCount <= 0) {\n    return resources.map((resource) => [resource]);\n  }\n\n  const totalCount = resources.reduce((total, resource) => {\n    return total + resource.count;\n  }, 0);\n\n  if (resources.length === 1 || totalCount <= maxCount) {\n    return [[...resources]];\n  }\n\n  const splitIndex = findPreferredSplitIndex(resources, maxCount);\n\n  if (splitIndex === undefined) {\n    return splitGreedily(resources, maxCount);\n  }\n\n  const left = resources.slice(0, splitIndex + 1);\n  const right = resources.slice(splitIndex + 1);\n\n  if (\n    left.length === 0 ||\n    right.length === 0 ||\n    left.length === resources.length ||\n    right.length === resources.length\n  ) {\n    return splitGreedily(resources, maxCount);\n  }\n\n  return [\n    ...splitResources(left, maxCount),\n    ...splitResources(right, maxCount),\n  ];\n}\n\nfunction findPreferredSplitIndex(\n  resources: readonly SegmentResource[],\n  maxCount: number,\n): number | undefined {\n  const totalCount = resources.reduce((total, resource) => {\n    return total + resource.count;\n  }, 0);\n  let leftCount = 0;\n  let bestIndex: number | undefined;\n  let bestBoundary = 0;\n  let bestOversizedSides = Number.POSITIVE_INFINITY;\n  let bestOverflow = Number.POSITIVE_INFINITY;\n\n  for (let index = 0; index < resources.length - 1; index += 1) {\n    const current = resources[index];\n    const next = resources[index + 1];\n\n    if (current === undefined || next === undefined) {\n      continue;\n    }\n\n    leftCount += current.count;\n    const rightCount = totalCount - leftCount;\n    const boundary = current.endIncision + next.startIncision;\n\n    if (boundary <= 0) {\n      continue;\n    }\n\n    const oversizedSides =\n      Number(leftCount > maxCount) + Number(rightCount > maxCount);\n    const overflow =\n      Math.max(0, leftCount - maxCount) + Math.max(0, rightCount - maxCount);\n\n    if (\n      oversizedSides < bestOversizedSides ||\n      (oversizedSides === bestOversizedSides && boundary > bestBoundary) ||\n      (oversizedSides === bestOversizedSides &&\n        boundary === bestBoundary &&\n        overflow < bestOverflow)\n    ) {\n      bestBoundary = boundary;\n      bestIndex = index;\n      bestOversizedSides = oversizedSides;\n      bestOverflow = overflow;\n    }\n  }\n\n  return bestIndex;\n}\n\nfunction splitGreedily(\n  resources: readonly SegmentResource[],\n  maxCount: number,\n): SegmentResource[][] {\n  const groups: SegmentResource[][] = [];\n  let currentGroup: SegmentResource[] = [];\n  let currentCount = 0;\n\n  for (const resource of resources) {\n    if (currentGroup.length > 0 && currentCount + resource.count > maxCount) {\n      groups.push(currentGroup);\n      currentGroup = [];\n      currentCount = 0;\n    }\n\n    currentGroup.push(resource);\n    currentCount += resource.count;\n\n    if (currentCount >= maxCount) {\n      groups.push(currentGroup);\n      currentGroup = [];\n      currentCount = 0;\n    }\n  }\n\n  if (currentGroup.length > 0) {\n    groups.push(currentGroup);\n  }\n\n  return groups;\n}\n"],"mappings":"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","names":[]}

package/dist/topology/segment-incision.d.ts

@@ -0,0 +1,18 @@
+import { ReadonlySerialTextStream } from '../document/text-streams.js';
+import { ChunkRecord, ReadingEdgeRecord } from '../document/types.js';
+import '../document/database.js';
+import 'sqlite3';
+
+interface SegmentInfo {
+    readonly startSentenceIndex: number;
+    readonly wordsCount: number;
+    readonly startIncision: number;
+    readonly endIncision: number;
+}
+declare function computeNormalizedSegmentIncisions(input: {
+    chunks: readonly ChunkRecord[];
+    edges: readonly ReadingEdgeRecord[];
+    fragments: ReadonlySerialTextStream;
+}): Promise<SegmentInfo[]>;
+
+export { type SegmentInfo, computeNormalizedSegmentIncisions };