@d-i-t-a/reader 2.1.0-alpha.2 → 2.1.0-beta.10

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

@@ -1,16 +1,32 @@
-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",
+    R2_ID_GUTTER_RIGHT_CONTAINER = "R2_ID_GUTTER_RIGHT_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 +35,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 +137,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 +148,13 @@ 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(event: TouchEvent | MouseEvent): void;
+    showTool: ((b: boolean) => void) & {
+        clear(): void;
+    };
+    snapSelectionToWord(trimmed?: boolean): any;
     toolboxShow(): void;
     isSelectionMenuOpen: boolean;
     selectionMenuOpened: (() => void) & {
@@ -130,6 +163,9 @@ export default class TextHighlighter {
     selectionMenuClosed: (() => void) & {
         clear(): void;
     };
+    selection: ((text: any, selection: any) => void) & {
+        clear(): void;
+    };
     toolboxPlacement(): void;
     toolboxHandler(): void;
     /**
@@ -141,8 +177,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 +218,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 +226,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 +244,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,72 @@
+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,
+    Comment = 6
+}
+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;
+}

package/dist/{modules → types/modules}/mediaoverlays/MediaOverlayModule.d.ts

@@ -1,6 +1,6 @@
 import { Publication } from "../../model/Publication";
-import IFrameNavigator from "../../navigator/IFrameNavigator";
-import ReaderModule from "../ReaderModule";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
 import { Link } from "../../model/Link";
 import { MediaOverlayNode } from "r2-shared-js/dist/es6-es2015/src/models/media-overlay";
 import { MediaOverlaySettings } from "./MediaOverlaySettings";
@@ -17,46 +17,49 @@ export interface MediaOverlayModuleProperties {
     autoScroll?: boolean;
     autoTurn?: boolean;
     volume?: number;
+    rate?: number;
     wait?: number;
+    hideLayer?: boolean;
 }
 export interface MediaOverlayModuleConfig extends MediaOverlayModuleProperties {
     publication: Publication;
     delegate: IFrameNavigator;
-    api: MediaOverlayModuleAPI;
     settings: MediaOverlaySettings;
+    api?: MediaOverlayModuleAPI;
 }
-export default class MediaOverlayModule implements ReaderModule {
+export declare class MediaOverlayModule implements ReaderModule {
     private publication;
     private delegate;
     private audioElement;
-    private settings;
+    settings: MediaOverlaySettings;
+    private properties;
     private play;
     private pause;
     private currentAudioBegin;
     private currentAudioEnd;
     private currentLinks;
     private currentLinkIndex;
-    private mediaOverlaysPlaybackRate;
     private currentAudioUrl;
     private previousAudioUrl;
     private previousAudioEnd;
     private mediaOverlayRoot;
     private mediaOverlayTextAudioPair;
     private pid;
-    static create(config: MediaOverlayModuleConfig): Promise<MediaOverlayModule>;
+    private __ontimeupdate;
+    static create(config: MediaOverlayModuleConfig): MediaOverlayModule;
     private constructor();
-    stop(): Promise<void>;
-    protected start(): Promise<void>;
+    stop(): void;
+    protected start(): void;
     initialize(): Promise<void>;
-    initializeResource(links: Array<Link>): Promise<void>;
+    initializeResource(links: Array<Link | undefined>): Promise<void>;
     private playLink;
     startReadAloud(): Promise<void>;
-    stopReadAloud(): void;
+    stopReadAloud(): Promise<void>;
     pauseReadAloud(): void;
     resumeReadAloud(): Promise<void>;
     findDepthFirstTextAudioPair(textHref: string, mo: MediaOverlayNode, textFragmentIDChain: Array<string | null> | undefined): MediaOverlayNode | undefined | null;
-    ontimeupdate: (ev: Event) => Promise<void>;
-    ensureOnTimeUpdate: (remove: boolean) => void;
+    myReq: any;
+    trackCurrentTime(): void;
     mediaOverlaysNext(escape?: boolean): void;
     mediaOverlaysStop(): void;
     mediaOverlaysPause(): void;
@@ -65,5 +68,7 @@ export default class MediaOverlayModule implements ReaderModule {
     }, escape: boolean): MediaOverlayNode | undefined | null;
     playMediaOverlaysAudio(moTextAudioPair: MediaOverlayNode, begin: number | undefined, end: number | undefined): Promise<void>;
     playMediaOverlays(textHref: string, rootMo: MediaOverlayNode, textFragmentIDChain: Array<string | null> | undefined): Promise<void>;
-    mediaOverlayHighlight(href: string | undefined, id: string | undefined): void;
+    ontimeupdate: (_v: Event) => Promise<void>;
+    ensureOnTimeUpdate: (remove: boolean, replace: boolean) => void;
+    mediaOverlayHighlight(id: string | undefined): void;
 }

package/dist/{modules → types/modules}/mediaoverlays/MediaOverlaySettings.d.ts

@@ -7,25 +7,29 @@ export declare class MEDIAOVERLAYREFS {
     static readonly AUTO_SCROLL_REF = "autoscroll";
     static readonly AUTO_TURN_REF = "autoturn";
     static readonly VOLUME_REF = "volume";
+    static readonly RATE_REF = "rate";
     static readonly COLOR_KEY: string;
     static readonly AUTO_SCROLL_KEY: string;
     static readonly AUTO_TURN_KEY: string;
     static readonly VOLUME_KEY: string;
+    static readonly RATE_KEY: string;
 }
 export interface MediaOverlayConfig {
     store: Store;
-    initialMediaOverlaySettings: MediaOverlayModuleProperties;
-    headerMenu: HTMLElement;
-    api: MediaOverlayModuleAPI;
+    initialMediaOverlaySettings?: MediaOverlayModuleProperties;
+    headerMenu?: HTMLElement | null;
+    api?: MediaOverlayModuleAPI;
 }
 export interface IMediaOverlayUserSettings {
     color?: string;
     autoScroll?: boolean;
     autoTurn?: boolean;
     volume?: number;
+    rate?: number;
     playing?: boolean;
     wait?: number;
 }
+export declare type MediaOverlayIncrementable = "mo_volume" | "mo_rate";
 export declare class MediaOverlaySettings implements IMediaOverlayUserSettings {
     private readonly store;
     private readonly MEDIAOVERLAYSETTINGS;
@@ -33,35 +37,36 @@ export declare class MediaOverlaySettings implements IMediaOverlayUserSettings {
     autoScroll: boolean;
     autoTurn: boolean;
     volume: number;
+    rate: number;
     playing: boolean;
+    resourceReady: boolean;
     wait: number;
     userProperties: UserProperties;
     private settingsChangeCallback;
     private settingsView;
-    private readonly headerMenu;
-    private volumeButtons;
+    private readonly headerMenu?;
     private speechAutoScroll;
     private speechAutoTurn;
     private speechVolume;
-    private readonly api;
-    static create(config: MediaOverlayConfig): Promise<any>;
-    protected constructor(store: Store, headerMenu: HTMLElement, api: MediaOverlayModuleAPI);
-    stop(): Promise<void>;
+    private speechRate;
+    private readonly api?;
+    static create(config: MediaOverlayConfig): any;
+    protected constructor(store: Store, api?: MediaOverlayModuleAPI, headerMenu?: HTMLElement | null);
+    stop(): void;
     private initialise;
     private reset;
     private initializeSelections;
     setControls(): void;
     private renderControls;
     onSettingsChange(callback: () => void): void;
-    private setupEvents;
     private storeProperty;
     private updateUserSettings;
     private getMediaOverlaySettings;
     private saveProperty;
-    getProperty(name: string): Promise<UserProperty>;
-    resetMediaOverlaySettings(): Promise<void>;
-    applyMediaOverlaySettings(mediaOverlaySettings: IMediaOverlayUserSettings): Promise<void>;
-    applyMediaOverlaySetting(key: any, value: any): Promise<void>;
-    increase(incremental: string): Promise<void>;
-    decrease(incremental: string): Promise<void>;
+    getProperty(name: string): UserProperty | null;
+    resetMediaOverlaySettings(): void;
+    applyMediaOverlaySettings(mediaOverlaySettings: IMediaOverlayUserSettings): void;
+    applyMediaOverlaySetting(key: any, value: any): void;
+    increase(incremental: MediaOverlayIncrementable): void;
+    decrease(incremental: MediaOverlayIncrementable): void;
 }

package/dist/types/modules/pagebreak/PageBreakModule.d.ts

@@ -0,0 +1,30 @@
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
+import { IHighlight } from "../highlight/common/highlight";
+import { ISelectionInfo } from "../highlight/common/selection";
+import { Publication } from "../../model/Publication";
+export interface PageBreakModuleProperties {
+    hideLayer?: boolean;
+}
+export interface PageBreakModuleConfig extends PageBreakModuleProperties {
+    delegate: IFrameNavigator;
+    headerMenu?: HTMLElement | null;
+    publication: Publication;
+}
+export declare class PageBreakModule implements ReaderModule {
+    private delegate;
+    private readonly headerMenu?;
+    private publication;
+    private properties;
+    private goToPageView;
+    private goToPageNumberInput;
+    private goToPageNumberButton;
+    static create(config: PageBreakModuleConfig): Promise<PageBreakModule>;
+    private constructor();
+    stop(): Promise<void>;
+    protected start(): Promise<void>;
+    private goToPageNumber;
+    handleResize(): Promise<void>;
+    drawPageBreaks(): Promise<void>;
+    createPageBreakHighlight(selectionInfo: ISelectionInfo, title: string): IHighlight;
+}

package/dist/{modules → types/modules}/positions/TimelineModule.d.ts

@@ -1,11 +1,11 @@
 import { Publication } from "../../model/Publication";
-import IFrameNavigator from "../../navigator/IFrameNavigator";
-import ReaderModule from "../ReaderModule";
+import { IFrameNavigator } from "../../navigator/IFrameNavigator";
+import { ReaderModule } from "../ReaderModule";
 export interface TimelineModuleConfig {
     publication: Publication;
     delegate: IFrameNavigator;
 }
-export default class TimelineModule implements ReaderModule {
+export declare class TimelineModule implements ReaderModule {
     private publication;
     private delegate;
     private timelineContainer;