@lingo-reader/mobi-parser/dist/index.d.ts

A mobi and kf8 parser

import { InputFile, EBookParser } from '@lingo-reader/shared';

type Offset = [number, number][]

/**
 * exth, or metadata
 */
type ExthKey = 100 | 101 | 103 | 104 | 105 | 106 | 108 | 109 |
  110 | 112 | 113 | 121 | 122 | 125 | 126 | 127 | 128 | 129 |
  132 | 201 | 202 | 503 | 524 | 527
type ExthName =
  'creator' | 'publisher' | 'description' | 'isbn' | 'subject' |
  'date' | 'contributor' | 'rights' | 'subjectCode' | 'source' |
  'asin' | 'boundary' | 'fixedLayout' | 'numResources' |
  'originalResolution' | 'zeroGutter' | 'zeroMargin' | 'coverURI' |
  'regionMagnification' | 'coverOffset' | 'thumbnailOffset' |
  'title' | 'language' | 'pageProgressionDirection'
type ExthType = 'string' | 'uint'
type IsMany = true | false
interface ExthRecord {
  100: ['creator', 'string', true]
  101: ['publisher', 'string', false]
  103: ['description', 'string', false]
  104: ['isbn', 'string', false]
  105: ['subject', 'string', true]
  106: ['date', 'string', false]
  108: ['contributor', 'string', true]
  109: ['rights', 'string', false]
  110: ['subjectCode', 'string', true]
  112: ['source', 'string', true]
  113: ['asin', 'string', false]
  121: ['boundary', 'uint', false]
  122: ['fixedLayout', 'string', false]
  125: ['numResources', 'uint', false]
  126: ['originalResolution', 'string', false]
  127: ['zeroGutter', 'string', false]
  128: ['zeroMargin', 'string', false]
  129: ['coverURI', 'string', false]
  132: ['regionMagnification', 'string', false]
  201: ['coverOffset', 'uint', false]
  202: ['thumbnailOffset', 'uint', false]
  503: ['title', 'string', false]
  524: ['language', 'string', true]
  527: ['pageProgressionDirection', 'string', false]
}
type ConvertExthRecord<T extends Record<ExthKey, [ExthName, ExthType, IsMany]>> = {
  [K in Extract<T[keyof T], [string, any, any]>[0]]?:
  Extract<T[keyof T], [K, any, any]>[2] extends true
    ? Extract<T[keyof T], [K, any, any]>[1] extends 'uint'
      ? number[]
      : string[]
    : Extract<T[keyof T], [K, any, any]>[1] extends 'uint'
      ? number
      : string
}
type Exth = ConvertExthRecord<ExthRecord>

type DecompressFunc = (data: Uint8Array) => Uint8Array

type LoadRecordFunc = (index: number) => ArrayBuffer

interface MobiChapter {
  id: string
  text: string
  start: number
  end: number
  size: number
}
type MobiSpine = MobiChapter[]

interface MobiTocItem {
  label: string
  href: string
  children?: MobiTocItem[]
}
type MobiToc = MobiTocItem[]

interface IndexTableItem {
  name: string
  tagMap: Record<number, number[]>
}
type IndexTable = IndexTableItem[]
type Cncx = Record<string, string>
interface IndexData { table: IndexTable, cncx: Cncx }

interface MobiMetadata {
  identifier: string
  title: string
  author: string[]
  publisher: string
  language: string
  published: string
  description: string
  subject: string[]
  rights: string
  contributor: string[]
}

interface MobiFileInfo {
  fileName: string
}

interface MobiCssPart {
  id: string
  href: string
}
interface MobiProcessedChapter {
  html: string
  css: MobiCssPart[]
}

interface MobiResolvedHref {
  id: string
  selector: string
}

/**
 * kf8 types
 */

interface SkelTableItem {
  index: number
  name: string
  numFrag: number
  offset: number
  length: number
}
type SkelTable = SkelTableItem[]

interface FragTableItem {
  insertOffset: number
  selector: string
  index: number
  offset: number
  length: number
}
type FragTable = FragTableItem[]

interface Kf8Chapter {
  id: string
  skel: SkelTableItem
  frags: FragTable
  fragEnd: number
  length: number
  totalLength: number
}
type Kf8Spine = Kf8Chapter[]

interface NcxItem {
  index: number
  offset: number
  size: number
  label: string
  headingLevel: number
  pos: number[]
  parent: number
  firstChild: number
  lastChild: number
  children?: NcxItem[]
}
type Ncx = NcxItem[]

interface Kf8TocItem {
  label: string
  href: string
  children?: Kf8TocItem[]
}
type Kf8Toc = Kf8TocItem[]

interface Kf8GuideItem {
  label: string
  type: string[]
  href: string
}
type Kf8Guide = Kf8GuideItem[]

interface Kf8CssPart {
  id: string
  href: string
}
interface Kf8ProcessedChapter {
  html: string
  css: Kf8CssPart[]
}

type Kf8ResolvedHref = MobiResolvedHref

type Kf8Metadata = MobiMetadata
type Kf8FileInfo = MobiFileInfo

declare function initKf8File(file: InputFile, resourceSaveDir?: string): Promise<Kf8>;
declare class Kf8 implements EBookParser {
    private file;
    private fileArrayBuffer;
    private mobiFile;
    private fileName;
    private fdstTable;
    private fullRawLength;
    private skelTable;
    private fragTable;
    private chapters;
    private toc;
    private fragmentOffsets;
    private fragmentSelectors;
    private rawHead;
    private rawTail;
    private lastLoadedHead;
    private lastLoadedTail;
    private resourceCache;
    private chapterCache;
    private idToChapter;
    private resourceSaveDir;
    getFileInfo(): Kf8FileInfo;
    getMetadata(): Kf8Metadata;
    getCoverImage(): string;
    getSpine(): Kf8Spine;
    getToc(): Kf8Toc;
    constructor(file: InputFile, resourceSaveDir?: string);
    innerLoadFile(): Promise<void>;
    innerInit(): Promise<void>;
    getGuide(): Kf8Guide | undefined;
    private loadRaw;
    private loadText;
    loadChapter(id: string): Kf8ProcessedChapter | undefined;
    private cacheFragmentSelector;
    private loadFlow;
    resolveHref(href: string): Kf8ResolvedHref | undefined;
    private replaceResources;
    private replace;
    destroy(): void;
}

declare function initMobiFile(file: InputFile, resourceSaveDir?: string): Promise<Mobi>;
declare class Mobi implements EBookParser {
    private file;
    private fileArrayBuffer;
    private mobiFile;
    private fileName;
    private chapters;
    private idToChapter;
    private toc;
    private resourceSaveDir;
    private chapterCache;
    private resourceCache;
    getFileInfo(): MobiFileInfo;
    getSpine(): MobiSpine;
    loadChapter(id: string): MobiProcessedChapter | undefined;
    getToc(): MobiToc;
    getCoverImage(): string;
    getMetadata(): MobiMetadata;
    constructor(file: InputFile, resourceSaveDir?: string);
    innerLoadFile(): Promise<void>;
    innerInit(): Promise<void>;
    private findTocChapter;
    private parseNavMap;
    private loadResource;
    private recindexReg;
    private mediarecindexReg;
    private fileposReg;
    private replace;
    resolveHref(href: string): MobiResolvedHref | undefined;
    destroy(): void;
}

export { type Cncx, type ConvertExthRecord, type DecompressFunc, type Exth, type ExthKey, type ExthName, type ExthRecord, type FragTable, type FragTableItem, type IndexData, type IndexTable, type IndexTableItem, Kf8, type Kf8Chapter, type Kf8CssPart, type Kf8FileInfo, type Kf8Guide, type Kf8GuideItem, type Kf8Metadata, type Kf8ProcessedChapter, type Kf8ResolvedHref, type Kf8Spine, type Kf8Toc, type Kf8TocItem, type LoadRecordFunc, Mobi, type MobiChapter, type MobiCssPart, type MobiFileInfo, type MobiMetadata, type MobiProcessedChapter, type MobiResolvedHref, type MobiSpine, type MobiToc, type MobiTocItem, type Ncx, type NcxItem, type Offset, type SkelTable, type SkelTableItem, initKf8File, initMobiFile };