@d-i-t-a/reader 2.1.0-alpha.3 → 2.1.0-beta.1

package/dist/{modules → types/modules}/TTS/TTSSettings.d.ts

@@ -1,6 +1,32 @@
 import Store from "../../store/Store";
 import { UserProperty, UserProperties } from "../../model/user-settings/UserProperties";
-import { TTSModuleAPI, TTSModuleProperties } from "./TTSModule";
+import { IFrameNavigator, ReaderRights } from "../../navigator/IFrameNavigator";
+import { TextHighlighter } from "../highlight/TextHighlighter";
+export interface TTSModuleAPI {
+    started: any;
+    stopped: any;
+    paused: any;
+    resumed: any;
+    finished: any;
+    updateSettings: any;
+}
+export interface TTSModuleProperties {
+    color?: string;
+    autoScroll?: boolean;
+    rate?: number;
+    pitch?: number;
+    volume?: number;
+    voice?: TTSVoice;
+    hideLayer?: boolean;
+}
+export interface TTSModuleConfig extends TTSModuleProperties {
+    delegate: IFrameNavigator;
+    rights: ReaderRights;
+    tts: TTSSettings;
+    highlighter: TextHighlighter;
+    headerMenu?: HTMLElement | null;
+    api?: TTSModuleAPI;
+}
 export declare class TTSREFS {
     static readonly COLOR_REF = "color";
     static readonly AUTO_SCROLL_REF = "autoscroll";
@@ -17,9 +43,9 @@ export declare class TTSREFS {
 }
 export interface TTSSettingsConfig {
     store: Store;
-    initialTTSSettings: TTSModuleProperties;
-    headerMenu: HTMLElement;
-    api: TTSModuleAPI;
+    initialTTSSettings?: TTSModuleProperties;
+    headerMenu?: HTMLElement | null;
+    api?: TTSModuleAPI;
 }
 export interface TTSVoice {
     usePublication: boolean;
@@ -35,6 +61,7 @@ export interface ITTSUserSettings {
     volume?: number;
     voice?: TTSVoice;
 }
+export declare type TTSIncrementable = "pitch" | "rate" | "volume";
 export declare class TTSSettings implements ITTSUserSettings {
     private readonly store;
     private readonly TTSSETTINGS;
@@ -45,37 +72,34 @@ export declare class TTSSettings implements ITTSUserSettings {
     volume: number;
     voice: TTSVoice;
     userProperties: UserProperties;
-    private rateButtons;
-    private pitchButtons;
-    private volumeButtons;
     private settingsChangeCallback;
+    private restartCallback;
     private settingsView;
-    private readonly headerMenu;
+    private readonly headerMenu?;
     private speechRate;
     private speechPitch;
     private speechVolume;
     private speechAutoScroll;
-    private readonly api;
-    static create(config: TTSSettingsConfig): Promise<any>;
-    protected constructor(store: Store, headerMenu: HTMLElement, api: TTSModuleAPI);
+    private readonly api?;
+    static create(config: TTSSettingsConfig): TTSSettings;
+    protected constructor(store: Store, api?: TTSModuleAPI, headerMenu?: HTMLElement | null);
     enableSplitter?: boolean;
-    stop(): Promise<void>;
+    stop(): void;
     private initialise;
     private reset;
     private initializeSelections;
     setControls(): void;
     private renderControls;
     onSettingsChange(callback: () => void): void;
-    private setupEvents;
+    onRestart(callback: () => void): void;
     private storeProperty;
     private updateUserSettings;
     private getTTSSettings;
     private saveProperty;
-    getProperty(name: string): Promise<UserProperty>;
-    resetTTSSettings(): Promise<void>;
-    applyTTSSettings(ttsSettings: ITTSUserSettings): Promise<void>;
-    applyPreferredVoice(value: any): Promise<void>;
-    applyTTSSetting(key: any, value: any): Promise<void>;
-    increase(incremental: string): Promise<void>;
-    decrease(incremental: string): Promise<void>;
+    getProperty(name: string): UserProperty | undefined;
+    resetTTSSettings(): void;
+    applyTTSSettings(ttsSettings: Partial<ITTSUserSettings>): void;
+    applyPreferredVoice(value: string): void;
+    increase(incremental: TTSIncrementable): void;
+    decrease(incremental: string): void;
 }

package/dist/types/modules/citation/CitationModule.d.ts

@@ -0,0 +1,40 @@
+import { Publication } from "../../model/Publication";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { TextHighlighter } from "../highlight/TextHighlighter";
+export declare enum CitationStyle {
+    Chicago = 0,
+    MLA = 1,
+    APA = 2
+}
+export declare enum ContributorType {
+    Author = "Author",
+    Editor = "Editor",
+    Translator = "Translator",
+    Compiler = "Compiler"
+}
+export interface CitationModuleProperties {
+    characters?: number;
+    appName?: string;
+    appLink?: string;
+    library?: string;
+    styles?: string[];
+}
+export interface CitationModuleConfig extends CitationModuleProperties {
+    publication: Publication;
+    delegate: IFrameNavigator;
+    highlighter: TextHighlighter;
+}
+export default class CitationModule implements ReaderModule {
+    private publication;
+    private delegate;
+    private properties;
+    private readonly highlighter?;
+    private constructor();
+    static create(config: CitationModuleConfig): Promise<CitationModule>;
+    stop(): Promise<void>;
+    copyToClipboard(textToClipboard: any): void;
+    createElementForExecCommand(textToClipboard: any): HTMLDivElement;
+    selectContent(element: any): void;
+    protected start(): Promise<void>;
+}

package/dist/types/modules/highlight/LayerSettings.d.ts

@@ -0,0 +1,19 @@
+import Store from "../../store/Store";
+import { UserProperty, UserProperties } from "../../model/user-settings/UserProperties";
+export interface LayerConfig {
+    store: Store;
+}
+export interface ILayerSettings {
+}
+export declare class LayerSettings implements ILayerSettings {
+    private readonly store;
+    private readonly LAYERSETTINGS;
+    userProperties: UserProperties;
+    static create(config: LayerConfig): Promise<any>;
+    protected constructor(store: Store);
+    stop(): Promise<void>;
+    private initialize;
+    private getLayerSettings;
+    saveProperty(property: UserProperty): Promise<any>;
+    getProperty(name: string): Promise<UserProperty | null>;
+}

package/dist/{modules → types/modules}/highlight/TextHighlighter.d.ts

@@ -1,16 +1,31 @@
-import { IColor, IHighlight } from "./common/highlight";
+import { HighlightType, IHighlight, IMarkerIcon, IPopupStyle, IStyle, SelectionMenuItem } from "./common/highlight";
 import { ISelectionInfo } from "./common/selection";
 import { IRectSimple } from "./common/rect-utils";
-import { IReadiumIFrameWindow } from "./renderer/iframe/state";
 import { AnnotationMarker } from "../../model/Locator";
-import IFrameNavigator, { SelectionMenuItem } from "../../navigator/IFrameNavigator";
-export declare const ID_HIGHLIGHTS_CONTAINER = "R2_ID_HIGHLIGHTS_CONTAINER";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { LayerSettings } from "./LayerSettings";
+export declare enum HighlightContainer {
+    R2_ID_HIGHLIGHTS_CONTAINER = "R2_ID_HIGHLIGHTS_CONTAINER",
+    R2_ID_BOOKMAKRS_CONTAINER = "R2_ID_BOOKMAKRS_CONTAINER",
+    R2_ID_READALOUD_CONTAINER = "R2_ID_READALOUD_CONTAINER",
+    R2_ID_PAGEBREAK_CONTAINER = "R2_ID_PAGEBREAK_CONTAINER",
+    R2_ID_SEARCH_CONTAINER = "R2_ID_SEARCH_CONTAINER",
+    R2_ID_DEFINITIONS_CONTAINER = "R2_ID_DEFINITIONS_CONTAINER",
+    R2_ID_LINEFOCUS_CONTAINER = "R2_ID_LINEFOCUS_CONTAINER"
+}
 export declare const CLASS_HIGHLIGHT_CONTAINER = "R2_CLASS_HIGHLIGHT_CONTAINER";
-export declare const CLASS_HIGHLIGHT_AREA = "R2_CLASS_HIGHLIGHT_AREA";
 export declare const CLASS_HIGHLIGHT_BOUNDING_AREA = "R2_CLASS_HIGHLIGHT_BOUNDING_AREA";
+export declare const CLASS_HIGHLIGHT_AREA = "R2_CLASS_HIGHLIGHT_AREA";
+export declare const CLASS_HIGHLIGHT_ICON = "R2_CLASS_HIGHLIGHT_ICON";
+export declare const DEFAULT_BACKGROUND_COLOR: {
+    blue: number;
+    green: number;
+    red: number;
+};
 export interface TextSelectorAPI {
     selectionMenuOpen: any;
     selectionMenuClose: any;
+    selection: any;
 }
 export declare const _highlights: IHighlight[];
 interface IWithRect {
@@ -19,20 +34,31 @@ interface IWithRect {
 }
 export interface IHTMLDivElementWithRect extends HTMLDivElement, IWithRect {
 }
+export interface HTMLElementRect {
+    node: Element;
+    height: number;
+    top: number;
+    width: number;
+    left: number;
+    textContent: string;
+}
 export interface TextHighlighterProperties {
-    selectionMenuItems: Array<SelectionMenuItem>;
+    selectionMenuItems?: Array<SelectionMenuItem>;
 }
 export interface TextHighlighterConfig extends TextHighlighterProperties {
     delegate: IFrameNavigator;
-    api: TextSelectorAPI;
+    api?: TextSelectorAPI;
+    layerSettings: LayerSettings;
 }
-export default class TextHighlighter {
+export declare class TextHighlighter {
     private options;
-    private delegate;
-    private lastSelectedHighlight;
-    private properties;
-    private api;
+    private readonly delegate;
+    layerSettings: LayerSettings;
+    private lastSelectedHighlight?;
+    properties: TextHighlighterProperties;
+    private api?;
     private hasEventListener;
+    activeAnnotationMarkerId?: string;
     static create(config: TextHighlighterConfig): Promise<any>;
     private constructor();
     initialize(): Promise<void>;
@@ -110,6 +136,9 @@ export default class TextHighlighter {
         stopPropagation: () => void;
     }): boolean;
     bindEvents(el: any, _scope: any, hasEventListener: boolean): void;
+    mousedown(ev: MouseEvent): Promise<void>;
+    mouseup(ev: MouseEvent): Promise<void>;
+    mousemove(ev: MouseEvent): Promise<void>;
     unbindEvents(el: any, _scope: any): void;
     /**
      * Permanently disables highlighting.
@@ -118,10 +147,10 @@ export default class TextHighlighter {
      */
     destroy(): void;
     initializeToolbox(): void;
-    toolboxMode(mode: "colors" | "edit" | "add"): void;
+    toolboxMode(mode: "colors" | "edit" | "add" | "action"): void;
     toolboxHide(): void;
-    toolboxShowDelayed(): void;
-    snapSelectionToWord(): any;
+    toolboxShowDelayed(ev: any): void;
+    snapSelectionToWord(trimmed?: boolean): any;
     toolboxShow(): void;
     isSelectionMenuOpen: boolean;
     selectionMenuOpened: (() => void) & {
@@ -130,6 +159,9 @@ export default class TextHighlighter {
     selectionMenuClosed: (() => void) & {
         clear(): void;
     };
+    selection: ((text: any, selection: any) => void) & {
+        clear(): void;
+    };
     toolboxPlacement(): void;
     toolboxHandler(): void;
     /**
@@ -141,8 +173,10 @@ export default class TextHighlighter {
     doHighlight(keepRange?: boolean, marker?: AnnotationMarker): void;
     speak(): void;
     stopReadAloud(): void;
-    speakAll(): void;
     callbackComplete(): void;
+    isOutsideViewport(rect: any): boolean;
+    isInsideViewport(rect: any): boolean;
+    get visibleTextRects(): HTMLElementRect[];
     doneSpeaking(reload?: boolean): void;
     /**
      * Normalizes highlights. Ensures that highlighting is done with use of the smallest possible number of
@@ -180,20 +214,6 @@ export default class TextHighlighter {
      * @memberof TextHighlighter
      */
     getColor(): string;
-    /**
-     * Returns highlights from given container.
-     * @param params
-     * @param {HTMLElement} [params.container] - return highlights from this element. Default: the element the
-     * highlighter is applied to.
-     * @param {boolean} [params.andSelf] - if set to true and container is a highlight itself, add container to
-     * returned results. Default: true.
-     * @param {boolean} [params.grouped] - if set to true, highlights are grouped in logical groups of highlights added
-     * in the same moment. Each group is an object which has got array of highlights, 'toString' method and 'timestamp'
-     * property. Default: false.
-     * @returns {Array} - array of highlights.
-     * @memberof TextHighlighter
-     */
-    getHighlights(params?: any): Array<any>;
     /**
      * Returns true if element is a highlight.
      * All highlights have 'data-highlighted' attribute.
@@ -202,20 +222,6 @@ export default class TextHighlighter {
      * @memberof TextHighlighter
      */
     isHighlight(el: any): boolean;
-    /**
-     * Serializes all highlights in the element the highlighter is applied to.
-     * @returns {string} - stringified JSON with highlights definition
-     * @memberof TextHighlighter
-     */
-    serializeHighlights(): string;
-    /**
-     * Deserializes highlights.
-     * @throws exception when can't parse JSON or JSON has invalid structure.
-     * @param {object} json - JSON object with highlights definition.
-     * @returns {Array} - array of deserialized highlights.
-     * @memberof TextHighlighter
-     */
-    deserializeHighlights(json: any): Array<any>;
     /**
      * Creates wrapper for highlights.
      * TextHighlighter instance calls this method each time it needs to create highlights and pass options retrieved
@@ -234,25 +240,23 @@ export default class TextHighlighter {
     };
     static hexToRgbA(hex: string): string;
     static hexToRgbAWithOpacity(hex: string, opacity: number): string;
-    resetHighlightBoundingStyle(_win: IReadiumIFrameWindow, highlightBounding: HTMLElement): void;
-    resetHighlightAreaStyle(_win: IReadiumIFrameWindow, highlightArea: HTMLElement): void;
-    setHighlightAreaStyle(_win: IReadiumIFrameWindow, highlightAreas: Array<HTMLElement>, highlight: IHighlight): void;
+    resetHighlightBoundingStyle(highlightBounding: HTMLElement): void;
+    resetHighlightAreaStyle(highlightArea: HTMLElement, id_container: string): void;
+    setHighlightAreaStyle(doc: any, highlightAreas: Array<HTMLElement>, highlight: IHighlight): void;
     setAndResetSearchHighlight(highlight: any, highlights: any): void;
     isIOS(): boolean;
     isAndroid(): boolean;
-    getScrollingElement: (documant: Document) => Element;
-    processMouseEvent(win: IReadiumIFrameWindow, ev: MouseEvent): Promise<void>;
-    ensureHighlightsContainer(win: IReadiumIFrameWindow): HTMLElement;
-    hideAllhighlights(_documant: Document): void;
-    destroyAllhighlights(documant: Document): void;
-    destroyHighlight(documant: Document, id: string): void;
-    recreateAllHighlightsRaw(win: IReadiumIFrameWindow): void;
-    recreateAllHighlightsDebounced: ((win: IReadiumIFrameWindow) => void) & {
-        clear(): void;
-    };
-    recreateAllHighlights(win: IReadiumIFrameWindow): void;
-    createSearchHighlight(selectionInfo: ISelectionInfo, color: string): IHighlight;
-    createHighlight(win: IReadiumIFrameWindow, selectionInfo: ISelectionInfo, color: IColor | undefined, pointerInteraction: boolean, marker: AnnotationMarker): IHighlight;
-    createHighlightDom(win: IReadiumIFrameWindow, highlight: IHighlight): HTMLDivElement | undefined;
+    getScrollingElement: (doc: Document | undefined) => Element;
+    processMouseEvent(ev: MouseEvent): Promise<void>;
+    prepareContainers(win: any): Promise<void>;
+    ensureHighlightsContainer(win: any, id: string): Promise<HTMLElement>;
+    hideAllhighlights(doc: Document): void;
+    destroyAllhighlights(doc: Document): void;
+    removeAllChildNodes(parent: any): void;
+    destroyHighlights(type: HighlightType): void;
+    destroyHighlight(doc: Document | null, id: string): void;
+    createHighlight(win: any, selectionInfo: ISelectionInfo, color: string | undefined, pointerInteraction: boolean, marker: AnnotationMarker, icon?: IMarkerIcon | undefined, popup?: IPopupStyle | undefined, style?: IStyle | undefined, type?: HighlightType | undefined, prefix?: string | undefined): [IHighlight, HTMLDivElement?];
+    createHighlightDom(win: any, highlight: IHighlight): HTMLDivElement | undefined;
+    addSelectionMenuItem(citationIconMenu: SelectionMenuItem): void;
 }
 export {};

package/dist/types/modules/highlight/common/highlight.d.ts

@@ -0,0 +1,71 @@
+import { ISelectionInfo } from "./selection";
+import { AnnotationMarker } from "../../../model/Locator";
+import { Definition } from "../../search/DefinitionsModule";
+export interface IColor {
+    red: number;
+    green: number;
+    blue: number;
+}
+export interface IStyleProperty {
+    property: string;
+    value: string;
+    priority?: string;
+}
+export interface IStyle {
+    default?: [IStyleProperty] | undefined;
+    hover?: [IStyleProperty] | undefined;
+    defaultClass?: string | undefined;
+    hoverClass?: string | undefined;
+}
+export interface IPopupStyle {
+    background?: string;
+    textColor?: string;
+    class?: string;
+}
+export interface IHighlightStyle {
+    style?: IStyle;
+    color?: string;
+}
+export interface IMarkerIcon {
+    id: string;
+    position: string;
+    title: string;
+    svgPath?: string;
+    color?: string;
+    class?: string;
+}
+export declare enum HighlightType {
+    Annotation = 0,
+    Search = 1,
+    ReadAloud = 2,
+    PageBreak = 3,
+    Definition = 4,
+    LineFocus = 5
+}
+export interface IHighlight {
+    id: string;
+    selectionInfo: ISelectionInfo;
+    pointerInteraction: boolean;
+    marker: AnnotationMarker;
+    icon?: IMarkerIcon | undefined;
+    popup?: IPopupStyle | undefined;
+    color: string;
+    style?: IStyle | undefined;
+    position?: number;
+    note?: string | null | undefined;
+    definition?: Definition | undefined;
+    type: HighlightType;
+}
+export interface SelectionMenuItem {
+    id: string;
+    callback?: any;
+    marker?: AnnotationMarker;
+    icon?: IMarkerIcon;
+    popup?: IPopupStyle;
+    highlight?: IHighlightStyle;
+    note?: boolean;
+}
+export interface IHighlightDefinition {
+    selectionInfo: ISelectionInfo | undefined;
+    color: string | undefined;
+}

package/dist/{modules → types/modules}/highlight/common/rect-utils.d.ts

@@ -9,7 +9,7 @@ export interface IRect extends IRectSimple {
     right: number;
 }
 export declare function getClientRectsNoOverlap(range: Range, doNotMergeHorizontallyAlignedRects: boolean): IRect[];
-export declare function getClientRectsNoOverlap_(clientRects: ClientRectList | DOMRectList, doNotMergeHorizontallyAlignedRects: boolean): IRect[];
+export declare function getClientRectsNoOverlap_(clientRects: DOMRectList, doNotMergeHorizontallyAlignedRects: boolean): IRect[];
 export declare function rectIntersect(rect1: IRect, rect2: IRect): IRect;
 export declare function rectSubtract(rect1: IRect, rect2: IRect): IRect[];
 export declare function rectContainsPoint(rect: IRect, x: number, y: number, tolerance: number): boolean;
@@ -17,7 +17,7 @@ export declare function rectContains(rect1: IRect, rect2: IRect, tolerance: numb
 export declare function getBoundingRect(rect1: IRect, rect2: IRect): IRect;
 export declare function rectsTouchOrOverlap(rect1: IRect, rect2: IRect, tolerance: number): boolean;
 export declare function mergeTouchingRects(rects: IRect[], tolerance: number, doNotMergeHorizontallyAlignedRects: boolean): IRect[];
-export declare function replaceOverlapingRects(rects: IRect[]): IRect[];
+export declare function replaceOverlappingRects(rects: IRect[]): IRect[];
 export declare function getRectOverlapX(rect1: IRect, rect2: IRect): number;
 export declare function getRectOverlapY(rect1: IRect, rect2: IRect): number;
 export declare function removeContainedRects(rects: IRect[], tolerance: number): IRect[];

package/dist/{modules → types/modules}/highlight/common/selection.d.ts

@@ -9,8 +9,13 @@ export interface IRangeInfo {
 export declare function sameRanges(r1: IRangeInfo, r2: IRangeInfo): boolean;
 export interface ISelectionInfo {
     rangeInfo: IRangeInfo;
-    cleanText: string;
-    rawText: string;
-    range: Range;
+    cleanText?: string;
+    rawText?: string;
+    range?: Range;
 }
 export declare function sameSelections(sel1: ISelectionInfo, sel2: ISelectionInfo): boolean;
+export declare const _getCssSelectorOptions: {
+    className: (_str: string) => boolean;
+    idName: (_str: string) => boolean;
+    tagName: (_str: string) => boolean;
+};

package/dist/{modules → types/modules}/highlight/renderer/iframe/selection.d.ts

@@ -1,7 +1,7 @@
 import { IRangeInfo, ISelectionInfo } from "../../common/selection";
 export declare function clearCurrentSelection(win: Window): void;
-export declare function getCurrentSelectionInfo(win: Window, getCssSelector: (element: Element) => string): ISelectionInfo | undefined;
+export declare function getCurrentSelectionInfo(win: Window, getCssSelector: (element: Element) => string | undefined): ISelectionInfo | undefined;
 export declare function createOrderedRange(startNode: Node, startOffset: number, endNode: Node, endOffset: number): Range | undefined;
-export declare function convertRange(range: Range, getCssSelector: (element: Element) => string): IRangeInfo | undefined;
+export declare function convertRange(range: Range, getCssSelector: (element: Element) => string | undefined): IRangeInfo | undefined;
 export declare function convertRangeInfo(documant: Document, rangeInfo: IRangeInfo): Range | undefined;
 export declare function normalizeRange(r: Range): Range;

package/dist/{modules → types/modules}/highlight/renderer/iframe/state.d.ts

@@ -5,9 +5,6 @@ export interface IReadiumIFrameWindowState {
     locationHashOverride: Element | undefined;
     locationHashOverrideInfo: IEventPayload_R2_EVENT_READING_LOCATION | undefined;
 }
-export interface IReadiumIFrameWindow extends Window {
-    READIUM2: IReadiumIFrameWindowState;
-}
 export interface IReadiumIFrameState {
     id: number;
     link: Link | undefined;

package/dist/types/modules/history/HistoryModule.d.ts

@@ -0,0 +1,34 @@
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { Locator } from "../../model/Locator";
+import { Publication } from "../../model/Publication";
+import Annotator from "../../store/Annotator";
+export interface HistoryModuleProperties {
+    hideLayer?: boolean;
+}
+export interface HistoryModuleConfig extends HistoryModuleProperties {
+    annotator: Annotator;
+    delegate: IFrameNavigator;
+    headerMenu?: HTMLElement | null;
+    publication: Publication;
+}
+export declare class HistoryModule implements ReaderModule {
+    readonly annotator: Annotator | null;
+    private delegate;
+    private readonly headerMenu?;
+    private publication;
+    private properties;
+    private historyForwardAnchorElement;
+    private historyBackAnchorElement;
+    private historyCurrentIndex;
+    private history;
+    private constructor();
+    static create(config: HistoryModuleConfig): Promise<HistoryModule>;
+    stop(): Promise<void>;
+    handleResize(): Promise<void>;
+    setup(): void;
+    push(locator: Locator, history: boolean): Promise<void>;
+    protected start(): Promise<void>;
+    private handleHistoryForwardClick;
+    private handleHistoryBackClick;
+}

package/dist/types/modules/linefocus/LineFocusModule.d.ts

@@ -0,0 +1,51 @@
+import { Publication } from "../../model/Publication";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { TextHighlighter } from "../highlight/TextHighlighter";
+export interface LineFocusModuleAPI {
+}
+export interface LineFocusModuleProperties {
+    api?: LineFocusModuleAPI;
+    lines?: number;
+    maxHeight?: number;
+}
+export interface LineFocusModuleConfig extends LineFocusModuleProperties {
+    api?: LineFocusModuleAPI;
+    publication: Publication;
+    delegate: IFrameNavigator;
+    highlighter: TextHighlighter;
+}
+export default class LineFocusModule implements ReaderModule {
+    properties: LineFocusModuleProperties;
+    api?: LineFocusModuleAPI;
+    private delegate;
+    private highlighter;
+    private hasEventListener;
+    lines: Array<HTMLElement>;
+    index: number;
+    isActive: boolean;
+    isDebug: boolean;
+    lineFocusContainer: HTMLElement | null;
+    readerContainer: HTMLElement | null;
+    lineFocusTopBlinder: HTMLElement | null;
+    lineFocusBottomBlinder: HTMLElement | null;
+    static create(config: LineFocusModuleConfig): Promise<LineFocusModule>;
+    private constructor();
+    stop(): Promise<void>;
+    protected start(): Promise<void>;
+    private keydown;
+    private keyup;
+    handleResize(): void;
+    enableLineFocus(): Promise<void>;
+    wrapperHeight: string | undefined;
+    disableLineFocus(resetHeight?: boolean): void;
+    lineFocus(): void;
+    currentLine(): void;
+    lineDown(): void;
+    lineUp(): void;
+    almostEqual(a: number, b: number, tolerance: number): boolean;
+    findRects(parent: HTMLElement): any;
+    findTextNodes(parentElement: Element, nodes?: Array<Element>): Array<Element>;
+    measureTextNodes(node: Element): any;
+    measureImageNodes(node: Element): any;
+}