@prose-reader/core 1.72.0 → 1.74.0

package/dist/cfi/generate/{getCfiForSpineItemPage.d.ts → generateCfiForSpineItemPage.d.ts}

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

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

@@ -7,8 +7,244 @@ 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>;
+        };
+    };
 } | {
     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>;
+        };
+    };
     node?: undefined;
     offset?: undefined;
 } | undefined;

package/dist/constants.d.ts

@@ -1,4 +1,3 @@
-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;

package/dist/context/Context.d.ts

@@ -1,9 +1,9 @@
 import { BehaviorSubject, Subject } from 'rxjs';
 import { Manifest } from '@prose-reader/shared';
 import { BridgeEvent } from './BridgeEvent';
-import { LoadOptions } from '../reader';
 
-export type State = Partial<Pick<LoadOptions, "containerElement">> & {
+export type ContextState = {
+    containerElement?: HTMLElement;
     manifest?: Manifest;
     hasVerticalWriting?: boolean;
     isUsingSpreadMode?: boolean;
@@ -21,40 +21,17 @@ export type State = Partial<Pick<LoadOptions, "containerElement">> & {
     };
 };
 export declare class Context {
-    _stateSubject: BehaviorSubject<State>;
+    _stateSubject: BehaviorSubject<ContextState>;
     bridgeEvent: BridgeEvent;
     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;
-        };
-    }>;
+    state$: import('rxjs').Observable<ContextState>;
     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;
+    update(newState: Partial<ContextState>): void;
     isRTL: () => boolean;
-    get state(): State;
+    get state(): ContextState;
     get manifest(): Manifest | undefined;
     get readingDirection(): "ltr" | "rtl" | undefined;
     getPageSize(): {

package/dist/createReaderWithEnhancer.d.ts

@@ -13,7 +13,7 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             mediaType?: string;
         };
     }) => HTMLElement;
-}) => Omit<Omit<Omit<{
+}) => Omit<Omit<Omit<Omit<{
     context: import('./context/Context').Context;
     spine: import('./spine/Spine').Spine;
     hookManager: import('.').HookManager<import('./hooks/types').CoreHook>;
@@ -27,12 +27,252 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             start: string;
             end: string;
         };
+        generateCfiForSpineItemPage: (params: {
+            pageIndex: number;
+            spineItem: import('./spineItem/createSpineItem').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>;
+                };
+            };
         } | {
             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>;
+                };
+            };
             node?: undefined;
             offset?: undefined;
         } | undefined;
@@ -40,7 +280,7 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
     navigation: {
         viewportFree$: import('rxjs').Observable<"free">;
         viewportBusy$: import('rxjs').Observable<"busy">;
-        readonly viewportPosition: {
+        getViewportPosition: () => {
             x: number;
             y: number;
         };
@@ -87,7 +327,7 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
     spineItemsObserver: import('./spine/SpineItemsObserver').SpineItemsObserver;
     spineItemsManager: import('./spine/SpineItemsManager').SpineItemsManager;
     layout: () => void;
-    load: (manifest: import('@prose-reader/shared').Manifest, loadOptions: import('./reader').LoadOptions) => void;
+    load: (options: Required<Pick<import('./context/Context').ContextState, "manifest" | "containerElement">>) => void;
     destroy: () => void;
     pagination: {
         state: import('./pagination/Pagination').PaginationInfo;
@@ -95,6 +335,14 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
     };
     settings: import('./settings/SettingsInterface').SettingsInterface<NonNullable<import('./settings/types').CoreInputSettings>, NonNullable<import('./settings/types').CoreOutputSettings | undefined>>;
     element$: import('rxjs').Observable<HTMLElement>;
+    layout$: import('rxjs').Observable<{
+        hasChanged: boolean;
+        spineItemsAbsolutePositions: import('./spine/SpineLayout').LayoutPosition[];
+        spineItemsPagesAbsolutePositions: import('./spine/SpineLayout').LayoutPosition[][];
+        pages: import('./spine/SpineLayout').PageLayoutInformation[];
+    }>;
+    viewportState$: import('rxjs').Observable<"free" | "busy">;
+    state$: import('rxjs').Observable<"idle" | "ready">;
     $: {
         state$: import('rxjs').Observable<{
             supportedPageTurnAnimation: NonNullable<import('./reader').ContextSettings[`pageTurnAnimation`]>[];
@@ -102,13 +350,8 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             supportedPageTurnDirection: NonNullable<import('./reader').ContextSettings[`pageTurnDirection`]>[];
             supportedComputedPageTurnDirection: NonNullable<import('./reader').ContextSettings[`pageTurnDirection`]>[];
         }>;
-        loadStatus$: import('rxjs').Observable<"idle" | "ready">;
         destroy$: import('rxjs').Subject<void>;
     };
-} & {
-    events: {
-        normalizeEventForViewport: ReturnType<typeof import('./enhancers/events/normalizeEventForViewport').createNormalizeEventForViewport>;
-    };
 } & {
     progression: {
         getPercentageEstimate: (context: import('./context/Context').Context, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
@@ -136,7 +379,7 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             theme$: import('rxjs').Observable<import('./enhancers/theme').Theme>;
         };
     };
-} & import('./enhancers/navigation/types').NavigationEnhancerOutput & import('./enhancers/zoom/types').Api, "settings"> & {
+}, "load"> & import('./enhancers/navigation/types').NavigationEnhancerOutput & import('./enhancers/zoom/types').EnhancerApi, "settings"> & {
     settings: import('./settings/SettingsInterface').SettingsInterface<import('./settings/types').CoreInputSettings & import('./enhancers/layoutEnhancer/types').InputSettings, import('./enhancers/layoutEnhancer/types').InputSettings & import('./settings/types').CoreInputSettings & import('./settings/types').ComputedCoreSettings>;
 } & {
     utils: {

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

@@ -1,8 +1,3 @@
 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>;
-    };
-};
+export declare const eventsEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

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

@@ -0,0 +1,3 @@
+export declare const __UNSAFE_REFERENCE_ORIGINAL_IFRAME_EVENT_KEY = "__UNSAFE_REFERENCE_ORIGINAL_IFRAME_EVENT";
+export declare const attachOriginalFrameEventToDocumentEvent: <E extends Event>(event: E, frameEvent: E) => void;
+export declare const getOriginalFrameEventFromDocumentEvent: <E extends Event>(event: E) => E | undefined;

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

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

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

@@ -1,4 +1,4 @@
 import { EnhancerOptions, EnhancerOutput, RootEnhancer } from '../types/enhancer';
 import { NavigationEnhancerOutput } from './types';
 
-export declare const navigationEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & NavigationEnhancerOutput;
+export declare const navigationEnhancer: <InheritOptions extends EnhancerOptions<RootEnhancer>, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => Omit<InheritOutput, "load"> & NavigationEnhancerOutput;

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

@@ -12,6 +12,10 @@ export declare class ManualNavigator {
     constructor(reader: Reader);
     turnRight(): void;
     turnLeft(): void;
+    turnTop(): void;
+    turnBottom(): void;
+    turnRightOrBottom(): void;
+    turnLeftOrTop(): void;
     goToCfi(cfi: string, options?: {
         animate: boolean;
     }): void;