@prose-reader/core 1.117.0 → 1.119.0

package/dist/cfi/generate/generateCfiForSpineItemPage.d.ts

@@ -1,5 +1,5 @@
-import { SpineItem } from '../../spineItem/createSpineItem';
 import { SpineItemLocator } from '../../spineItem/locationResolver';
+import { SpineItem } from '../../spineItem/SpineItem';
 export declare const generateCfiForSpineItemPage: (({ pageIndex, spineItem, spineItemLocator, }: {
     pageIndex: number;
     spineItem: SpineItem;

package/dist/cfi/generate/getItemAnchor.d.ts

@@ -1,2 +1,2 @@
-import { SpineItem } from '../../spineItem/createSpineItem';
+import { SpineItem } from '../../spineItem/SpineItem';
 export declare const getItemAnchor: (spineItem: SpineItem) => string;

package/dist/cfi/generate/getRootCfi.d.ts

@@ -1,2 +1,2 @@
-import { SpineItem } from '../../spineItem/createSpineItem';
+import { SpineItem } from '../../spineItem/SpineItem';
 export declare const getRootCfi: (spineItem: SpineItem) => string;

package/dist/cfi/lookup/resolveCfi.d.ts

@@ -6,244 +6,10 @@ export declare const resolveCfi: ({ cfi, spineItemsManager, }: {
     node: Node | undefined;
     offset: number | undefined;
     spineItemIndex: number;
-    spineItem: {
-        layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
-            blankPagePosition: `before` | `after` | `none`;
-            minimumWidth: number;
-            spreadPosition: `none` | `left` | `right`;
-        }) => {
-            width: number;
-            height: number;
-        };
-        item: {
-            id: string;
-            href: string;
-            renditionLayout?: `reflowable` | `pre-paginated`;
-            progressionWeight?: number;
-            pageSpreadLeft?: true | undefined;
-            pageSpreadRight?: true | undefined;
-            mediaType?: string;
-        };
-        overlayElement: HTMLDivElement;
-        adjustPositionOfElement: ({ right, left, top, }: {
-            right?: number;
-            left?: number;
-            top?: number;
-        }) => void;
-        getElementDimensions: () => {
-            width: number;
-            height: number;
-            x: number;
-            y: number;
-            bottom: number;
-            left: number;
-            right: number;
-            top: number;
-            toJSON(): any;
-        };
-        getHtmlFromResource: (response: Response) => Promise<string>;
-        getResource: () => Promise<Response>;
-        translateFramePositionIntoPage: (position: {
-            clientX: number;
-            clientY: number;
-        }) => {
-            clientX: number;
-            clientY: number;
-        };
-        injectStyle: (cssText: string) => void;
-        load: () => void;
-        unload: () => void;
-        frame: import('../../spineItem/frame/FrameItem').FrameItem;
-        element: HTMLElement;
-        getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
-        getViewPortInformation: () => {
-            computedScale: number;
-            computedWidthScale: number;
-            viewportDimensions: {
-                width: number;
-                height: number;
-            };
-        } | undefined;
-        isImageType: () => boolean;
-        isReady: () => boolean;
-        destroy: () => void;
-        readingDirection: "ltr" | "rtl" | undefined;
-        isUsingVerticalWriting: () => boolean | undefined;
-        executeOnLayoutBeforeMeasurementHook: (options: {
-            minimumWidth: number;
-        }) => void[];
-        selectionTracker: {
-            track: (frameToTrack: HTMLIFrameElement) => void;
-            destroy: () => void;
-            isSelecting: () => boolean;
-            getSelection: () => Selection | undefined;
-            $: import('rxjs').Observable<{
-                event: `selectionchange`;
-                data: Selection | null;
-            } | {
-                event: `selectstart`;
-                data: Selection | null;
-            } | {
-                event: `selectend`;
-                data: Selection | null;
-            }>;
-        };
-        fingerTracker: {
-            track: (frame: HTMLIFrameElement) => void;
-            getFingerPositionInIframe(): {
-                x: number | undefined;
-                y: number | undefined;
-            } | undefined;
-            destroy: () => void;
-            $: import('rxjs').Observable<{
-                event: `fingermove`;
-                data: {
-                    x: number;
-                    y: number;
-                };
-            } | {
-                event: `fingerout`;
-                data: undefined;
-            }>;
-        };
-        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
-            columnHeight: number;
-            columnWidth: number;
-            width: number;
-        };
-        getDimensionsForPaginatedContent: () => {
-            columnHeight: number;
-            columnWidth: number;
-        };
-        $: {
-            contentLayout$: import('rxjs').Observable<{
-                isFirstLayout: boolean;
-                isReady: boolean;
-            }>;
-            loaded$: import('rxjs').Observable<HTMLIFrameElement>;
-            isReady$: import('rxjs').Observable<boolean>;
-        };
-    };
+    spineItem: import('../../spineItem/SpineItem').SpineItem;
 } | {
     spineItemIndex: number;
-    spineItem: {
-        layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
-            blankPagePosition: `before` | `after` | `none`;
-            minimumWidth: number;
-            spreadPosition: `none` | `left` | `right`;
-        }) => {
-            width: number;
-            height: number;
-        };
-        item: {
-            id: string;
-            href: string;
-            renditionLayout?: `reflowable` | `pre-paginated`;
-            progressionWeight?: number;
-            pageSpreadLeft?: true | undefined;
-            pageSpreadRight?: true | undefined;
-            mediaType?: string;
-        };
-        overlayElement: HTMLDivElement;
-        adjustPositionOfElement: ({ right, left, top, }: {
-            right?: number;
-            left?: number;
-            top?: number;
-        }) => void;
-        getElementDimensions: () => {
-            width: number;
-            height: number;
-            x: number;
-            y: number;
-            bottom: number;
-            left: number;
-            right: number;
-            top: number;
-            toJSON(): any;
-        };
-        getHtmlFromResource: (response: Response) => Promise<string>;
-        getResource: () => Promise<Response>;
-        translateFramePositionIntoPage: (position: {
-            clientX: number;
-            clientY: number;
-        }) => {
-            clientX: number;
-            clientY: number;
-        };
-        injectStyle: (cssText: string) => void;
-        load: () => void;
-        unload: () => void;
-        frame: import('../../spineItem/frame/FrameItem').FrameItem;
-        element: HTMLElement;
-        getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
-        getViewPortInformation: () => {
-            computedScale: number;
-            computedWidthScale: number;
-            viewportDimensions: {
-                width: number;
-                height: number;
-            };
-        } | undefined;
-        isImageType: () => boolean;
-        isReady: () => boolean;
-        destroy: () => void;
-        readingDirection: "ltr" | "rtl" | undefined;
-        isUsingVerticalWriting: () => boolean | undefined;
-        executeOnLayoutBeforeMeasurementHook: (options: {
-            minimumWidth: number;
-        }) => void[];
-        selectionTracker: {
-            track: (frameToTrack: HTMLIFrameElement) => void;
-            destroy: () => void;
-            isSelecting: () => boolean;
-            getSelection: () => Selection | undefined;
-            $: import('rxjs').Observable<{
-                event: `selectionchange`;
-                data: Selection | null;
-            } | {
-                event: `selectstart`;
-                data: Selection | null;
-            } | {
-                event: `selectend`;
-                data: Selection | null;
-            }>;
-        };
-        fingerTracker: {
-            track: (frame: HTMLIFrameElement) => void;
-            getFingerPositionInIframe(): {
-                x: number | undefined;
-                y: number | undefined;
-            } | undefined;
-            destroy: () => void;
-            $: import('rxjs').Observable<{
-                event: `fingermove`;
-                data: {
-                    x: number;
-                    y: number;
-                };
-            } | {
-                event: `fingerout`;
-                data: undefined;
-            }>;
-        };
-        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
-            columnHeight: number;
-            columnWidth: number;
-            width: number;
-        };
-        getDimensionsForPaginatedContent: () => {
-            columnHeight: number;
-            columnWidth: number;
-        };
-        $: {
-            contentLayout$: import('rxjs').Observable<{
-                isFirstLayout: boolean;
-                isReady: boolean;
-            }>;
-            loaded$: import('rxjs').Observable<HTMLIFrameElement>;
-            isReady$: import('rxjs').Observable<boolean>;
-        };
-    };
+    spineItem: import('../../spineItem/SpineItem').SpineItem;
     node?: undefined;
     offset?: undefined;
 } | undefined;

package/dist/context/Context.d.ts

@@ -32,7 +32,7 @@ export declare class Context {
     isRTL: () => boolean;
     get state(): ContextState;
     get manifest(): Manifest | undefined;
-    get readingDirection(): "ltr" | "rtl" | undefined;
+    get readingDirection(): "rtl" | "ltr" | undefined;
     getPageSize(): {
         width: number;
         height: number;

package/dist/createReaderWithEnhancer.d.ts

@@ -29,250 +29,16 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
         };
         generateCfiForSpineItemPage: (params: {
             pageIndex: number;
-            spineItem: import('./spineItem/createSpineItem').SpineItem;
+            spineItem: import('./spineItem/SpineItem').SpineItem;
         }) => string;
         resolveCfi: (params: Omit<Parameters<typeof import('./cfi/lookup/resolveCfi').resolveCfi>[0], "spineItemsManager">) => {
             node: Node | undefined;
             offset: number | undefined;
             spineItemIndex: number;
-            spineItem: {
-                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
-                    blankPagePosition: `before` | `after` | `none`;
-                    minimumWidth: number;
-                    spreadPosition: `none` | `left` | `right`;
-                }) => {
-                    width: number;
-                    height: number;
-                };
-                item: {
-                    id: string;
-                    href: string;
-                    renditionLayout?: `reflowable` | `pre-paginated`;
-                    progressionWeight?: number;
-                    pageSpreadLeft?: true | undefined;
-                    pageSpreadRight?: true | undefined;
-                    mediaType?: string;
-                };
-                overlayElement: HTMLDivElement;
-                adjustPositionOfElement: ({ right, left, top, }: {
-                    right?: number;
-                    left?: number;
-                    top?: number;
-                }) => void;
-                getElementDimensions: () => {
-                    width: number;
-                    height: number;
-                    x: number;
-                    y: number;
-                    bottom: number;
-                    left: number;
-                    right: number;
-                    top: number;
-                    toJSON(): any;
-                };
-                getHtmlFromResource: (response: Response) => Promise<string>;
-                getResource: () => Promise<Response>;
-                translateFramePositionIntoPage: (position: {
-                    clientX: number;
-                    clientY: number;
-                }) => {
-                    clientX: number;
-                    clientY: number;
-                };
-                injectStyle: (cssText: string) => void;
-                load: () => void;
-                unload: () => void;
-                frame: import('./spineItem/frame/FrameItem').FrameItem;
-                element: HTMLElement;
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
-                getViewPortInformation: () => {
-                    computedScale: number;
-                    computedWidthScale: number;
-                    viewportDimensions: {
-                        width: number;
-                        height: number;
-                    };
-                } | undefined;
-                isImageType: () => boolean;
-                isReady: () => boolean;
-                destroy: () => void;
-                readingDirection: "ltr" | "rtl" | undefined;
-                isUsingVerticalWriting: () => boolean | undefined;
-                executeOnLayoutBeforeMeasurementHook: (options: {
-                    minimumWidth: number;
-                }) => void[];
-                selectionTracker: {
-                    track: (frameToTrack: HTMLIFrameElement) => void;
-                    destroy: () => void;
-                    isSelecting: () => boolean;
-                    getSelection: () => Selection | undefined;
-                    $: import('rxjs').Observable<{
-                        event: `selectionchange`;
-                        data: Selection | null;
-                    } | {
-                        event: `selectstart`;
-                        data: Selection | null;
-                    } | {
-                        event: `selectend`;
-                        data: Selection | null;
-                    }>;
-                };
-                fingerTracker: {
-                    track: (frame: HTMLIFrameElement) => void;
-                    getFingerPositionInIframe(): {
-                        x: number | undefined;
-                        y: number | undefined;
-                    } | undefined;
-                    destroy: () => void;
-                    $: import('rxjs').Observable<{
-                        event: `fingermove`;
-                        data: {
-                            x: number;
-                            y: number;
-                        };
-                    } | {
-                        event: `fingerout`;
-                        data: undefined;
-                    }>;
-                };
-                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
-                    columnHeight: number;
-                    columnWidth: number;
-                    width: number;
-                };
-                getDimensionsForPaginatedContent: () => {
-                    columnHeight: number;
-                    columnWidth: number;
-                };
-                $: {
-                    contentLayout$: import('rxjs').Observable<{
-                        isFirstLayout: boolean;
-                        isReady: boolean;
-                    }>;
-                    loaded$: import('rxjs').Observable<HTMLIFrameElement>;
-                    isReady$: import('rxjs').Observable<boolean>;
-                };
-            };
+            spineItem: import('./spineItem/SpineItem').SpineItem;
         } | {
             spineItemIndex: number;
-            spineItem: {
-                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
-                    blankPagePosition: `before` | `after` | `none`;
-                    minimumWidth: number;
-                    spreadPosition: `none` | `left` | `right`;
-                }) => {
-                    width: number;
-                    height: number;
-                };
-                item: {
-                    id: string;
-                    href: string;
-                    renditionLayout?: `reflowable` | `pre-paginated`;
-                    progressionWeight?: number;
-                    pageSpreadLeft?: true | undefined;
-                    pageSpreadRight?: true | undefined;
-                    mediaType?: string;
-                };
-                overlayElement: HTMLDivElement;
-                adjustPositionOfElement: ({ right, left, top, }: {
-                    right?: number;
-                    left?: number;
-                    top?: number;
-                }) => void;
-                getElementDimensions: () => {
-                    width: number;
-                    height: number;
-                    x: number;
-                    y: number;
-                    bottom: number;
-                    left: number;
-                    right: number;
-                    top: number;
-                    toJSON(): any;
-                };
-                getHtmlFromResource: (response: Response) => Promise<string>;
-                getResource: () => Promise<Response>;
-                translateFramePositionIntoPage: (position: {
-                    clientX: number;
-                    clientY: number;
-                }) => {
-                    clientX: number;
-                    clientY: number;
-                };
-                injectStyle: (cssText: string) => void;
-                load: () => void;
-                unload: () => void;
-                frame: import('./spineItem/frame/FrameItem').FrameItem;
-                element: HTMLElement;
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
-                getViewPortInformation: () => {
-                    computedScale: number;
-                    computedWidthScale: number;
-                    viewportDimensions: {
-                        width: number;
-                        height: number;
-                    };
-                } | undefined;
-                isImageType: () => boolean;
-                isReady: () => boolean;
-                destroy: () => void;
-                readingDirection: "ltr" | "rtl" | undefined;
-                isUsingVerticalWriting: () => boolean | undefined;
-                executeOnLayoutBeforeMeasurementHook: (options: {
-                    minimumWidth: number;
-                }) => void[];
-                selectionTracker: {
-                    track: (frameToTrack: HTMLIFrameElement) => void;
-                    destroy: () => void;
-                    isSelecting: () => boolean;
-                    getSelection: () => Selection | undefined;
-                    $: import('rxjs').Observable<{
-                        event: `selectionchange`;
-                        data: Selection | null;
-                    } | {
-                        event: `selectstart`;
-                        data: Selection | null;
-                    } | {
-                        event: `selectend`;
-                        data: Selection | null;
-                    }>;
-                };
-                fingerTracker: {
-                    track: (frame: HTMLIFrameElement) => void;
-                    getFingerPositionInIframe(): {
-                        x: number | undefined;
-                        y: number | undefined;
-                    } | undefined;
-                    destroy: () => void;
-                    $: import('rxjs').Observable<{
-                        event: `fingermove`;
-                        data: {
-                            x: number;
-                            y: number;
-                        };
-                    } | {
-                        event: `fingerout`;
-                        data: undefined;
-                    }>;
-                };
-                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
-                    columnHeight: number;
-                    columnWidth: number;
-                    width: number;
-                };
-                getDimensionsForPaginatedContent: () => {
-                    columnHeight: number;
-                    columnWidth: number;
-                };
-                $: {
-                    contentLayout$: import('rxjs').Observable<{
-                        isFirstLayout: boolean;
-                        isReady: boolean;
-                    }>;
-                    loaded$: import('rxjs').Observable<HTMLIFrameElement>;
-                    isReady$: import('rxjs').Observable<boolean>;
-                };
-            };
+            spineItem: import('./spineItem/SpineItem').SpineItem;
             node?: undefined;
             offset?: undefined;
         } | undefined;
@@ -296,11 +62,11 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             getNavigationForSpineItemPage: (params: Omit<Parameters<typeof import('./navigation/resolvers/getNavigationForSpineItemPage').getNavigationForSpineItemPage>[0], "context" | "spineItemsManager" | "spineItemNavigationResolver" | "spineLocator">) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationFromSpineItemPosition: (params: {
                 spineItemPosition: import('./spineItem/types').UnsafeSpineItemPosition;
-                spineItem: import('./spineItem/createSpineItem').SpineItem;
+                spineItem: import('./spineItem/SpineItem').SpineItem;
             }) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationForCfi: (cfi: string) => import('./navigation/viewport/ViewportNavigator').ViewportPosition | undefined;
-            getNavigationForLastPage: (spineItem: import('./spineItem/createSpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
-            getNavigationForSpineIndexOrId: (indexOrId: number | string | import('./spineItem/createSpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            getNavigationForLastPage: (spineItem: import('./spineItem/SpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            getNavigationForSpineIndexOrId: (indexOrId: number | string | import('./spineItem/SpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getMostPredominantNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getAdjustedPositionWithSafeEdge: (position: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => {
@@ -318,9 +84,9 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             }) => boolean;
             getAdjustedPositionForSpread: (position: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             spineItemNavigator: {
-                getNavigationForLastPage: (spineItem: import('./spineItem/createSpineItem').SpineItem) => import('./spineItem/types').SafeSpineItemPosition;
-                getNavigationForPosition: (spineItem: import('./spineItem/createSpineItem').SpineItem, position: import('./spineItem/types').UnsafeSpineItemPosition) => import('./spineItem/types').SafeSpineItemPosition;
-                getNavigationFromNode: (spineItem: import('./spineItem/createSpineItem').SpineItem, node: Node, offset: number) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationForLastPage: (spineItem: import('./spineItem/SpineItem').SpineItem) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationForPosition: (spineItem: import('./spineItem/SpineItem').SpineItem, position: import('./spineItem/types').UnsafeSpineItemPosition) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationFromNode: (spineItem: import('./spineItem/SpineItem').SpineItem, node: Node, offset: number) => import('./spineItem/types').SafeSpineItemPosition;
             };
         };
     };
@@ -357,11 +123,11 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
         getPercentageEstimate: (context: import('./context/Context').Context, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
             x: number;
             y: number;
-        }, currentItem: import('./spineItem/createSpineItem').SpineItem) => number;
+        }, currentItem: import('./spineItem/SpineItem').SpineItem) => number;
         getScrollPercentageWithinItem: (context: import('./context/Context').Context, currentPosition: {
             x: number;
             y: number;
-        }, currentItem: import('./spineItem/createSpineItem').SpineItem) => number;
+        }, currentItem: import('./spineItem/SpineItem').SpineItem) => number;
     };
 }, "pagination"> & {
     pagination: Omit<{

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

@@ -1,2 +1,3 @@
+import { Context } from '../../context/Context';
 import { SpineLocator } from '../../spine/locator/SpineLocator';
-export declare const normalizeEventForViewport: <E extends MouseEvent | TouchEvent | PointerEvent>(event: E, iframeOriginalEvent: E, locator: SpineLocator) => E;
+export declare const normalizeEventForViewport: <E extends MouseEvent | TouchEvent | PointerEvent>(event: E, iframeOriginalEvent: E, locator: SpineLocator, context: Context) => E;

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

@@ -0,0 +1,12 @@
+export declare const translateFramePositionIntoPage: ({ position, frameElement, pageWidth, pageHeight, }: {
+    position: {
+        clientX: number;
+        clientY: number;
+    };
+    frameElement: HTMLIFrameElement;
+    pageWidth: number;
+    pageHeight: number;
+}) => {
+    clientX: number;
+    clientY: number;
+};

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

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

package/dist/enhancers/html/renderer/HtmlRenderer.d.ts

@@ -0,0 +1,26 @@
+import { Manifest } from '@prose-reader/shared';
+import { Context } from '../../../context/Context';
+import { ReaderSettingsManager } from '../../../settings/ReaderSettingsManager';
+import { HookManager } from '../../../hooks/HookManager';
+import { DocumentRenderer } from '../../../spineItem/DocumentRenderer';
+import { ResourceHandler } from '../../../spineItem/ResourceHandler';
+export declare class HtmlRenderer extends DocumentRenderer {
+    latestContentHeightWhenLoaded: number | undefined;
+    constructor(context: Context, settings: ReaderSettingsManager, hookManager: HookManager, item: Manifest[`spineItems`][number], containerElement: HTMLElement, resourcesHandler: ResourceHandler);
+    onCreateDocument(): import('rxjs').Observable<never>;
+    onLoadDocument(): import('rxjs').Observable<HTMLIFrameElement>;
+    onUnload(): import('rxjs').Observable<never>;
+    layout({ minPageSpread, blankPagePosition, spreadPosition, }: {
+        minPageSpread: number;
+        blankPagePosition: `before` | `after` | `none`;
+        spreadPosition: `none` | `left` | `right`;
+    }): {
+        width: number;
+        height: number;
+    };
+    private isImageType;
+    private getFrameElement;
+    getComputedStyleAfterLoad(): CSSStyleDeclaration | undefined;
+    get writingMode(): `vertical-rl` | `horizontal-tb` | undefined;
+    get readingDirection(): "rtl" | "ltr" | undefined;
+}

package/dist/{spineItem/frame/loader → enhancers/html/renderer}/attachFrameSrc.d.ts

@@ -1,7 +1,9 @@
 import { Observable } from 'rxjs';
-import { ReaderSettingsManager } from '../../../settings/ReaderSettingsManager';
 import { Manifest } from '@prose-reader/shared';
-export declare const attachFrameSrc: ({ settings, item, }: {
+import { ReaderSettingsManager } from '../../../settings/ReaderSettingsManager';
+import { ResourceHandler } from '../../../spineItem/ResourceHandler';
+export declare const attachFrameSrc: ({ item, resourcesHandler, }: {
     settings: ReaderSettingsManager;
     item: Manifest[`spineItems`][number];
+    resourcesHandler: ResourceHandler;
 }) => (stream: Observable<HTMLIFrameElement>) => Observable<HTMLIFrameElement>;

package/dist/{spineItem/frame → enhancers/html/renderer}/createHtmlPageFromResource.d.ts

@@ -1,2 +1,2 @@
-import { Manifest } from '../..';
+import { Manifest } from '../../..';
 export declare const createHtmlPageFromResource: (resourceResponse: Response | string, item: Manifest[`spineItems`][number]) => Promise<string>;

package/dist/enhancers/html/renderer/prePaginated/renderPrePaginated.d.ts

@@ -0,0 +1,31 @@
+export declare const getStyleForViewportDocument: () => string;
+export declare const getViewPortInformation: ({ pageHeight, pageWidth, frameElement, }: {
+    pageWidth: number;
+    pageHeight: number;
+    frameElement: HTMLIFrameElement;
+}) => {
+    computedScale: number;
+    computedWidthScale: number;
+    viewportDimensions: {
+        hasViewport: boolean;
+        width: number;
+        height: number;
+    } | {
+        hasViewport: boolean;
+        width?: undefined;
+        height?: undefined;
+    };
+} | undefined;
+export declare const renderPrePaginated: ({ minPageSpread, blankPagePosition, spreadPosition, pageHeight, pageWidth, frameElement, isRTL, enableTouch, }: {
+    minPageSpread: number;
+    blankPagePosition: `before` | `after` | `none`;
+    spreadPosition: `none` | `left` | `right`;
+    pageWidth: number;
+    pageHeight: number;
+    frameElement?: HTMLIFrameElement;
+    isRTL: boolean;
+    enableTouch: boolean;
+}) => {
+    width: number;
+    height: number;
+};