@prose-reader/core 1.56.0 → 1.58.0

package/dist/cfi.d.ts

@@ -0,0 +1,74 @@
+declare class CFI {
+    isRange: boolean;
+    parts: {}[];
+    opts: {};
+    cfi: string;
+    constructor(str: string, opts: {});
+    removeIllegalOpts(parts: any[]): void;
+    static generatePart(node: Element | Node, offset?: number, extra?: {}): string;
+    static generate(node: Node, offset?: number, extra?: {}): string;
+    static toParsed(cfi: any): any;
+    static comparePath(a: any[], b: any[]): number;
+    static sort(a: any): void;
+    static compare(a: any, b: any): number;
+    static compareParts(a: any, b: any): number;
+    decodeEntities(dom: Document, str: string): string;
+    trueLength(dom: Document, str: string): number;
+    getFrom(): any;
+    getTo(): any;
+    get(): any;
+    parseSideBias(o: any, loc: any): void;
+    parseSpatialRange(range: any): {
+        x: number;
+        y: number;
+    } | undefined;
+    parse(cfi: any): {
+        parsed: {};
+        offset: number;
+        newDoc: boolean;
+    };
+    getChildNodeByCFIIndex(dom: Document, parentNode: Element, index: number, offset: number): {
+        relativeToNode: string;
+        offset: number;
+    } | {
+        node: ChildNode | undefined;
+        relativeToNode: string;
+        offset: number;
+    } | {
+        node: ChildNode | undefined;
+        offset: number;
+        relativeToNode?: undefined;
+    } | undefined;
+    isTextNode(node: Element): boolean;
+    correctOffset(dom: Document, node: Element, offset: number, assertion: any): {
+        node: Element;
+        offset: any;
+    };
+    resolveNode(index: number, subparts: {
+        nodeIndex: number;
+        nodeID?: string;
+        offset?: number;
+    }[], dom: Document, opts: {}): {
+        node: Document;
+        offset: number;
+    };
+    resolveURI(index: number, dom: Document, opts: {
+        ignoreIDs?: boolean;
+    }): any;
+    deepClone(o: any): any;
+    resolveLocation(dom: Document, parts: {}[]): any;
+    resolveLast(dom: Document, opts: {}): string | {};
+    resolve(doc: Document, opts: {}): {
+        node: Node;
+        offset?: number;
+    } | {
+        node?: undefined;
+        offset?: number;
+    };
+}
+export { CFI };
+export declare const extractProseMetadataFromCfi: (cfi: string) => {
+    cleanedCfi: string;
+    itemId?: string;
+    offset?: number;
+};

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const __UNSAFE_REFERENCE_ORIGINAL_IFRAME_EVENT_KEY = "__UNSAFE_REFERENCE_ORIGINAL_IFRAME_EVENT";
+export declare const PROSE_READER_NAMESPACE = "@prose-reader/core";
+export declare const VIEWPORT_ADJUSTMENT_THROTTLE = 0;
+export declare const PAGINATION_UPDATE_AFTER_VIEWPORT_ADJUSTMENT_DEBOUNCE = 200;
+export declare const ITEM_EXTENSION_VALID_FOR_FRAME_SRC: string[];
+export declare const HTML_PREFIX = "prose-reader";

package/dist/context/Context.d.ts

@@ -0,0 +1,63 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { Manifest } from '@prose-reader/shared';
+import { LoadOptions } from '../types/reader';
+
+export type State = Partial<Pick<LoadOptions, "containerElement">> & {
+    manifest?: Manifest;
+    hasVerticalWriting?: boolean;
+    isUsingSpreadMode?: boolean;
+    isFullyPrePaginated?: boolean;
+    forceSinglePageMode?: boolean;
+    areAllItemsPrePaginated?: boolean;
+    calculatedInnerMargin: number;
+    marginTop: number;
+    marginBottom: number;
+    visibleAreaRect: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    };
+};
+export declare class Context {
+    _stateSubject: BehaviorSubject<State>;
+    destroy$: Subject<void>;
+    state$: import('rxjs').Observable<Partial<Pick<LoadOptions, "containerElement">> & {
+        manifest?: Manifest;
+        hasVerticalWriting?: boolean;
+        isUsingSpreadMode?: boolean;
+        isFullyPrePaginated?: boolean;
+        forceSinglePageMode?: boolean;
+        areAllItemsPrePaginated?: boolean;
+        calculatedInnerMargin: number;
+        marginTop: number;
+        marginBottom: number;
+        visibleAreaRect: {
+            width: number;
+            height: number;
+            x: number;
+            y: number;
+        };
+    }>;
+    manifest$: import('rxjs').Observable<Manifest>;
+    containerElement$: import('rxjs').Observable<HTMLElement>;
+    hasVerticalWriting$: import('rxjs').Observable<boolean>;
+    isUsingSpreadMode$: import('rxjs').Observable<boolean | undefined>;
+    update(newState: {
+        manifest?: Manifest;
+        forceSinglePageMode?: boolean;
+        visibleAreaRect?: State["visibleAreaRect"];
+        marginTop?: number;
+        marginBottom?: number;
+        hasVerticalWriting?: boolean;
+    }): void;
+    isRTL: () => boolean;
+    get state(): State;
+    get manifest(): Manifest | undefined;
+    get readingDirection(): "ltr" | "rtl" | undefined;
+    getPageSize(): {
+        width: number;
+        height: number;
+    };
+    destroy: () => void;
+}

package/dist/context/isUsingSpreadMode.d.ts

@@ -0,0 +1,10 @@
+import { Manifest } from '@prose-reader/shared';
+
+export declare const isUsingSpreadMode: ({ manifest, visibleAreaRect, forceSinglePageMode, }: {
+    manifest?: Manifest;
+    visibleAreaRect: {
+        height: number;
+        width: number;
+    };
+    forceSinglePageMode?: boolean;
+}) => boolean;

package/dist/createReaderWithEnhancer.d.ts

@@ -0,0 +1,271 @@
+export declare const createReaderWithEnhancers: (options: Partial<import('./settings/types').Settings> & {
+    theme?: import('./enhancers/theme').Theme;
+} & import('./enhancers/layoutEnhancer/types').SettingsInput & {
+    layoutAutoResize?: `container` | false;
+} & {
+    fontScale?: number;
+    lineHeight?: number | `publisher`;
+    fontWeight?: (200 | 300 | 100 | 400 | 500 | 600 | 700 | 800 | 900) | `publisher`;
+    fontJustification?: ("center" | "right" | "left" | "justify") | `publisher`;
+} & {
+    loadingElementCreate?: (options: {
+        container: HTMLElement;
+        item: {
+            id: string;
+            href: string;
+            renditionLayout: `reflowable` | `pre-paginated`;
+            progressionWeight: number;
+            pageSpreadLeft: true | undefined;
+            pageSpreadRight: true | undefined;
+            mediaType?: string;
+        };
+    }) => HTMLElement;
+}) => Omit<Omit<Omit<Omit<import('./types/reader').ReaderInternal & {
+    events: {
+        normalizeEventForViewport: ReturnType<typeof import('./enhancers/events/normalizeEventForViewport').createNormalizeEventForViewport>;
+    };
+} & {
+    progression: {
+        getPercentageEstimate: (context: import('./context/Context').Context, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import('./spineItem/createSpineItem').SpineItem) => number;
+        getScrollPercentageWithinItem: (context: import('./context/Context').Context, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: import('./spineItem/createSpineItem').SpineItem) => number;
+    };
+}, "pagination"> & {
+    pagination: Omit<{
+        destroy: () => void;
+        updateBeginAndEnd: ((begin: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }, end: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }) => void) | ((begin: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        } & {
+            spineItemIndex: number;
+        }, end: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        } & {
+            spineItemIndex: number;
+        }) => ReturnType<(begin: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }, end: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }) => void>);
+        getPaginationInfo: () => import('./pagination/types').PaginationInfo;
+        paginationInfo$: import('rxjs').Observable<import('./pagination/types').PaginationInfo>;
+    }, "paginationInfo$" | "getPaginationInfo"> & {
+        paginationInfo$: import('rxjs').Observable<import('./pagination/types').PaginationInfo & import('./enhancers/pagination/types').ExtraPaginationInfo>;
+        getPaginationInfo: () => import('./pagination/types').PaginationInfo & import('./enhancers/pagination/types').ExtraPaginationInfo;
+    };
+} & {
+    theme: {
+        set: (theme: import('./enhancers/theme').Theme) => void;
+        get: () => import('./enhancers/theme').Theme;
+        $: {
+            theme$: import('rxjs').Observable<import('./enhancers/theme').Theme>;
+        };
+    };
+} & {
+    navigation: ReturnType<typeof import('./enhancers/navigation/navigator').createNavigator> & {
+        state$: ReturnType<typeof import('./enhancers/navigation/state').createState>;
+    };
+} & import('./enhancers/zoom/types').Api, "settings"> & {
+    settings: Omit<import('./settings/SettingsManager').SettingsManager, "setSettings" | "settings$"> & {
+        settings$: import('rxjs').Observable<import('./settings/types').Settings & {
+            computedPageTurnMode: import('./settings/types').Settings[`pageTurnMode`];
+            computedPageTurnDirection: import('./settings/types').Settings[`pageTurnDirection`];
+            computedPageTurnAnimation: import('./settings/types').Settings[`pageTurnAnimation`];
+            computedPageTurnAnimationDuration: number;
+            computedSnapAnimationDuration: number;
+        } & Required<import('./enhancers/layoutEnhancer/types').SettingsInput>>;
+        setSettings: (settings: Partial<import('./settings/types').Settings> & import('./enhancers/layoutEnhancer/types').SettingsInput) => void;
+    };
+} & {
+    utils: {
+        isOrIsWithinValidLink: (target: Event[`target`]) => boolean;
+    };
+} & {
+    $: {
+        links$: import('rxjs').Observable<{
+            event: `linkClicked`;
+            data: HTMLAnchorElement;
+            isNavigable: boolean;
+        }>;
+    };
+}, "settings"> & {
+    settings: Omit<Omit<import('./settings/SettingsManager').SettingsManager, "setSettings" | "settings$"> & {
+        settings$: import('rxjs').Observable<import('./settings/types').Settings & {
+            computedPageTurnMode: import('./settings/types').Settings[`pageTurnMode`];
+            computedPageTurnDirection: import('./settings/types').Settings[`pageTurnDirection`];
+            computedPageTurnAnimation: import('./settings/types').Settings[`pageTurnAnimation`];
+            computedPageTurnAnimationDuration: number;
+            computedSnapAnimationDuration: number;
+        } & Required<import('./enhancers/layoutEnhancer/types').SettingsInput>>;
+        setSettings: (settings: Partial<import('./settings/types').Settings> & import('./enhancers/layoutEnhancer/types').SettingsInput) => void;
+    }, "setSettings" | "settings$"> & {
+        settings$: import('rxjs').Observable<import('./settings/types').Settings & {
+            computedPageTurnMode: import('./settings/types').Settings[`pageTurnMode`];
+            computedPageTurnDirection: import('./settings/types').Settings[`pageTurnDirection`];
+            computedPageTurnAnimation: import('./settings/types').Settings[`pageTurnAnimation`];
+            computedPageTurnAnimationDuration: number;
+            computedSnapAnimationDuration: number;
+        } & Required<import('./enhancers/layoutEnhancer/types').SettingsInput> & Required<{
+            fontScale?: number;
+            lineHeight?: number | `publisher`;
+            fontWeight?: (200 | 300 | 100 | 400 | 500 | 600 | 700 | 800 | 900) | `publisher`;
+            fontJustification?: ("center" | "right" | "left" | "justify") | `publisher`;
+        }>>;
+        setSettings: (settings: Partial<import('./settings/types').Settings> & import('./enhancers/layoutEnhancer/types').SettingsInput & {
+            fontScale?: number;
+            lineHeight?: number | `publisher`;
+            fontWeight?: (200 | 300 | 100 | 400 | 500 | 600 | 700 | 800 | 900) | `publisher`;
+            fontJustification?: ("center" | "right" | "left" | "justify") | `publisher`;
+        }) => void;
+    };
+} & {
+    loading: {
+        $: {
+            items$: import('rxjs').Observable<{
+                [key: string]: HTMLElement;
+            }>;
+        };
+    };
+}, "pagination"> & {
+    pagination: Pick<Omit<{
+        destroy: () => void;
+        updateBeginAndEnd: ((begin: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }, end: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }) => void) | ((begin: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        } & {
+            spineItemIndex: number;
+        }, end: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        } & {
+            spineItemIndex: number;
+        }) => ReturnType<(begin: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }, end: Parameters<(info: {
+            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            pageIndex: number;
+            cfi: string | undefined;
+            options: {
+                isAtEndOfChapter?: boolean;
+            };
+        }) => {
+            numberOfPages: number;
+            pageIndex: number;
+            cfi: string | undefined;
+        }>[0] & {
+            spineItemIndex: number;
+        }) => void>);
+        getPaginationInfo: () => import('./pagination/types').PaginationInfo;
+        paginationInfo$: import('rxjs').Observable<import('./pagination/types').PaginationInfo>;
+    }, "paginationInfo$" | "getPaginationInfo"> & {
+        paginationInfo$: import('rxjs').Observable<import('./pagination/types').PaginationInfo & import('./enhancers/pagination/types').ExtraPaginationInfo>;
+        getPaginationInfo: () => import('./pagination/types').PaginationInfo & import('./enhancers/pagination/types').ExtraPaginationInfo;
+    }, "paginationInfo$" | "getPaginationInfo">;
+};

package/dist/enhancers/accessibility.d.ts

@@ -0,0 +1,3 @@
+import { EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+export declare const accessibilityEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/chrome.d.ts

@@ -0,0 +1,3 @@
+import { EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+export declare const chromeEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/events/createIframeEventBridgeElement.d.ts

@@ -0,0 +1 @@
+export declare const createIframeEventBridgeElement: (container: HTMLElement) => HTMLDivElement;

package/dist/enhancers/events/events.d.ts

@@ -0,0 +1,8 @@
+import { EnhancerOutput, RootEnhancer } from '../types/enhancer';
+import { createNormalizeEventForViewport } from './normalizeEventForViewport';
+
+export declare const eventsEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
+    events: {
+        normalizeEventForViewport: ReturnType<typeof createNormalizeEventForViewport>;
+    };
+};

package/dist/enhancers/events/normalizeEventForViewport.d.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject } from 'rxjs';
+import { createLocationResolver } from '../../spine/locationResolver';
+
+export declare const createNormalizeEventForViewport: ({ iframeEventBridgeElement$, locator, }: {
+    iframeEventBridgeElement$: BehaviorSubject<HTMLElement | undefined>;
+    locator: ReturnType<typeof createLocationResolver>;
+}) => <E extends MouseEvent | TouchEvent | PointerEvent>(event: E) => E;

package/dist/enhancers/firefox.d.ts

@@ -0,0 +1,3 @@
+import { EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+export declare const firefoxEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/fonts.d.ts

@@ -0,0 +1,19 @@
+import { Observable, ObservedValueOf } from 'rxjs';
+import { EnhancerOptions, EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+declare const FONT_WEIGHT: readonly [100, 200, 300, 400, 500, 600, 700, 800, 900];
+declare const FONT_JUSTIFICATION: readonly ["center", "left", "right", "justify"];
+type Options = {
+    fontScale?: number;
+    lineHeight?: number | `publisher`;
+    fontWeight?: (typeof FONT_WEIGHT)[number] | `publisher`;
+    fontJustification?: (typeof FONT_JUSTIFICATION)[number] | `publisher`;
+};
+type OutputOptions = Required<Options>;
+export declare const fontsEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>, SetSettings extends (settings: Parameters<InheritOutput["settings"]["setSettings"]>[0] & Options) => void, Settings$ extends Observable<ObservedValueOf<InheritOutput["settings"]["settings$"]> & OutputOptions>, Output extends Omit<InheritOutput, "settings"> & {
+    settings: Omit<InheritOutput["settings"], "setSettings" | "settings$"> & {
+        settings$: Settings$;
+        setSettings: SetSettings;
+    };
+}>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions & Options) => Output;
+export {};

package/dist/enhancers/hotkeys.d.ts

@@ -0,0 +1,3 @@
+import { EnhancerOptions, EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+export declare const hotkeysEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/layoutEnhancer/createMovingSafePan$.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import { Reader } from '../../reader';
+
+export declare const createMovingSafePan$: (reader: Reader) => Observable<unknown>;

package/dist/enhancers/layoutEnhancer/fixReflowable.d.ts

@@ -0,0 +1,3 @@
+import { Reader } from '../../reader';
+
+export declare const fixReflowable: (reader: Reader) => void;

package/dist/enhancers/layoutEnhancer/layoutEnhancer.d.ts

@@ -0,0 +1,10 @@
+import { Observable, ObservedValueOf } from 'rxjs';
+import { Options, SettingsInput, SettingsOutput } from './types';
+import { EnhancerOptions, EnhancerOutput, RootEnhancer } from '../types/enhancer';
+
+export declare const layoutEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>, Settings$ extends InheritOutput["settings"]["settings$"], SetSettings extends (settings: Parameters<InheritOutput["settings"]["setSettings"]>[0] & SettingsInput) => void, Output extends Omit<InheritOutput, "settings"> & {
+    settings: Omit<InheritOutput["settings"], "setSettings" | "settings$"> & {
+        settings$: Observable<ObservedValueOf<Settings$> & SettingsOutput>;
+        setSettings: SetSettings;
+    };
+}>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions & Options) => Output;

package/dist/enhancers/layoutEnhancer/types.d.ts

@@ -0,0 +1,8 @@
+export type SettingsInput = {
+    pageHorizontalMargin?: number;
+    pageVerticalMargin?: number;
+};
+export type SettingsOutput = Required<SettingsInput>;
+export type Options = SettingsInput & {
+    layoutAutoResize?: `container` | false;
+};

package/dist/enhancers/links.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { EnhancerOptions, EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+type SubjectData = {
+    event: `linkClicked`;
+    data: HTMLAnchorElement;
+    isNavigable: boolean;
+};
+export declare const linksEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
+    $: {
+        links$: Observable<SubjectData>;
+    };
+};
+export {};

package/dist/enhancers/loadingEnhancer.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { Manifest } from '../types';
+import { EnhancerOutput } from './types/enhancer';
+import { themeEnhancer } from './theme';
+
+type Entries = {
+    [key: string]: HTMLElement;
+};
+type Item = Manifest[`spineItems`][number];
+type Options = {
+    loadingElementCreate?: (options: {
+        container: HTMLElement;
+        item: Item;
+    }) => HTMLElement;
+};
+type Output = {
+    loading: {
+        $: {
+            items$: Observable<Entries>;
+        };
+    };
+};
+export declare const loadingEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<typeof themeEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions & Options) => InheritOutput & Output;
+export {};

package/dist/enhancers/media.d.ts

@@ -0,0 +1,3 @@
+import { EnhancerOutput, RootEnhancer } from './types/enhancer';
+
+export declare const mediaEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/navigation/navigation.d.ts

@@ -0,0 +1,9 @@
+import { EnhancerOptions, EnhancerOutput, RootEnhancer } from '../types/enhancer';
+import { createNavigator } from './navigator';
+import { createState } from './state';
+
+export declare const navigationEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
+    navigation: ReturnType<typeof createNavigator> & {
+        state$: ReturnType<typeof createState>;
+    };
+};

package/dist/enhancers/navigation/navigator.d.ts

@@ -0,0 +1,8 @@
+import { Reader } from '../../reader';
+
+export declare const createNavigator: (reader: Reader) => {
+    goToNextSpineItem: () => void;
+    goToPreviousSpineItem: () => void;
+    goToLeftSpineItem: () => void;
+    goToRightSpineItem: () => void;
+};

package/dist/enhancers/navigation/state.d.ts

@@ -0,0 +1,12 @@
+import { Reader } from '../../reader';
+
+export type State = {
+    canGoLeftSpineItem: boolean;
+    canGoRightSpineItem: boolean;
+};
+export declare const createState: (reader: Reader) => import('rxjs').Observable<{
+    canGoTopSpineItem: boolean;
+    canGoBottomSpineItem: boolean;
+    canGoLeftSpineItem: boolean;
+    canGoRightSpineItem: boolean;
+}>;

package/dist/enhancers/pagination/chapters.d.ts

@@ -0,0 +1,24 @@
+import { Reader } from '../../reader';
+
+export type ChapterInfo = {
+    title: string;
+    subChapter?: {
+        title: string;
+        subChapter?: {
+            title: string;
+            subChapter?: {
+                title: string;
+                path: string;
+            };
+            path: string;
+        };
+        path: string;
+    };
+    path: string;
+};
+export declare const getChaptersInfo: (reader: Reader) => {
+    [key: string]: ChapterInfo | undefined;
+};
+export declare const trackChapterInfo: (reader: Reader) => import('rxjs').Observable<{
+    [key: string]: ChapterInfo | undefined;
+}>;

package/dist/enhancers/pagination/constants.d.ts

@@ -0,0 +1 @@
+export declare const NAMESPACE = "paginationEnhancer";

package/dist/enhancers/pagination/enhancer.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { progressionEnhancer } from '../progression';
+import { EnhancerOutput } from '../types/enhancer';
+import { PaginationInfo } from '../../pagination/types';
+import { ExtraPaginationInfo } from './types';
+
+type ProgressionEnhancer = typeof progressionEnhancer;
+export declare const paginationEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<ProgressionEnhancer>, PaginationOutput extends Omit<InheritOutput["pagination"], "paginationInfo$" | "getPaginationInfo"> & {
+    paginationInfo$: Observable<PaginationInfo & ExtraPaginationInfo>;
+    getPaginationInfo: () => PaginationInfo & ExtraPaginationInfo;
+}>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => Omit<InheritOutput, "pagination"> & {
+    pagination: PaginationOutput;
+};
+export {};