@prose-reader/core 1.28.0 → 1.29.0

package/dist/viewportNavigator/manualViewportNavigator.d.ts

@@ -1,1697 +1,1440 @@
-import { BehaviorSubject } from "rxjs"
-import { Context } from "../context"
-import { SpineItemManager } from "../spineItemManager"
-import { createNavigationResolver, ViewportNavigationEntry } from "../spine/navigationResolver"
-import { createLocationResolver } from "../spine/locationResolver"
-export declare const createManualViewportNavigator: ({
-  navigator,
-  spineItemManager,
-  currentNavigationSubject$,
-  locator,
-  context,
-}: {
-  context: Context
-  element: HTMLElement
-  navigator: ReturnType<typeof createNavigationResolver>
-  currentNavigationSubject$: BehaviorSubject<ViewportNavigationEntry>
-  spineItemManager: SpineItemManager
-  locator: ReturnType<typeof createLocationResolver>
+import { BehaviorSubject } from "rxjs";
+import { Context } from "../context";
+import { SpineItemManager } from "../spineItemManager";
+import { createNavigationResolver, ViewportNavigationEntry } from "../spine/navigationResolver";
+import { createLocationResolver } from "../spine/locationResolver";
+export declare const createManualViewportNavigator: ({ navigator, spineItemManager, currentNavigationSubject$, locator, context, }: {
+    context: Context;
+    element: HTMLElement;
+    navigator: ReturnType<typeof createNavigationResolver>;
+    currentNavigationSubject$: BehaviorSubject<ViewportNavigationEntry>;
+    spineItemManager: SpineItemManager;
+    locator: ReturnType<typeof createLocationResolver>;
 }) => {
-  destroy: () => void
-  adjustReadingOffset: () => boolean
-  turnLeft: ({ allowSpineItemChange }?: { allowSpineItemChange?: boolean | undefined }) => void
-  turnRight: ({ allowSpineItemChange }?: { allowSpineItemChange?: boolean | undefined }) => void
-  goToCfi: (
-    cfi: string,
-    options?: {
-      animate: boolean
-    }
-  ) => void
-  goToPageOfCurrentChapter: (pageIndex: number) => void
-  goToSpineItem: (
-    indexOrId: number | string,
-    options?: {
-      animate: boolean
-    }
-  ) => void
-  goToUrl: (url: string | URL) => void
-  goToPage: (pageIndex: number) => void
-  $: {
-    state$: import("rxjs").Observable<"start" | "end">
-    navigation$: import("rxjs").Observable<
-      | {
-          animate: boolean
-          lastUserExpectedNavigation: {
-            type: "navigate-from-anchor"
-            data: string
-          }
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+    destroy: () => void;
+    adjustReadingOffset: () => boolean;
+    turnLeft: ({ allowSpineItemChange }?: {
+        allowSpineItemChange?: boolean | undefined;
+    }) => void;
+    turnRight: ({ allowSpineItemChange }?: {
+        allowSpineItemChange?: boolean | undefined;
+    }) => void;
+    goToCfi: (cfi: string, options?: {
+        animate: boolean;
+    }) => void;
+    goToPageOfCurrentChapter: (pageIndex: number) => void;
+    goToSpineItem: (indexOrId: number | string, options?: {
+        animate: boolean;
+    }) => void;
+    goToUrl: (url: string | URL) => void;
+    goToPage: (pageIndex: number) => void;
+    $: {
+        state$: import("rxjs").Observable<"start" | "end">;
+        navigation$: import("rxjs").Observable<{
+            animate: boolean;
+            lastUserExpectedNavigation: {
+                type: "navigate-from-anchor";
+                data: string;
+            };
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-          url: URL
-        }
-      | {
-          animate: boolean
-          lastUserExpectedNavigation: {
-            type: "navigate-from-previous-item"
-          }
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+            url: URL;
+        } | {
+            animate: boolean;
+            lastUserExpectedNavigation: {
+                type: "navigate-from-previous-item";
+            };
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-        }
-      | {
-          lastUserExpectedNavigation: undefined
-          animate: boolean
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+        } | {
+            lastUserExpectedNavigation: undefined;
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-        }
-      | {
-          lastUserExpectedNavigation: {
-            type: "navigate-from-next-item"
-          }
-          animate: boolean
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+        } | {
+            lastUserExpectedNavigation: {
+                type: "navigate-from-next-item";
+            };
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-        }
-      | {
-          lastUserExpectedNavigation: {
-            type: "navigate-from-previous-item"
-          }
-          animate: boolean
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+        } | {
+            lastUserExpectedNavigation: {
+                type: "navigate-from-previous-item";
+            };
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-        }
-      | {
-          lastUserExpectedNavigation: undefined
-          animate: boolean
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+        } | {
+            lastUserExpectedNavigation: undefined;
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-        }
-      | {
-          animate: boolean
-          lastUserExpectedNavigation: {
-            type: "navigate-from-cfi"
-            data: string
-          }
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+        } | {
+            animate: boolean;
+            lastUserExpectedNavigation: {
+                type: "navigate-from-cfi";
+                data: string;
+            };
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-        }
-      | {
-          lastUserExpectedNavigation: undefined
-          animate: boolean
-          x: number
-          y: number
-          spineItem?:
-            | {
-                layout: ({
-                  blankPagePosition,
-                  minimumWidth,
-                  spreadPosition,
-                }: {
-                  blankPagePosition: "after" | "before" | "none"
-                  minimumWidth: number
-                  spreadPosition: "none" | "right" | "left"
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+        } | {
+            lastUserExpectedNavigation: undefined;
+            animate: boolean;
+            x: number;
+            y: number;
+            spineItem?: {
+                layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+                    blankPagePosition: "after" | "before" | "none";
+                    minimumWidth: number;
+                    spreadPosition: "none" | "right" | "left";
                 }) => {
-                  width: number
-                  height: number
-                }
+                    width: number;
+                    height: number;
+                };
                 item: {
-                  id: string
-                  href: string
-                  renditionLayout: "reflowable" | "pre-paginated"
-                  progressionWeight: number
-                  pageSpreadLeft: true | undefined
-                  pageSpreadRight: true | undefined
-                  mediaType?: string | undefined
-                }
-                load: () => void
-                adjustPositionOfElement: ({
-                  right,
-                  left,
-                  top,
-                }: {
-                  right?: number | undefined
-                  left?: number | undefined
-                  top?: number | undefined
-                }) => void
+                    id: string;
+                    href: string;
+                    renditionLayout: "reflowable" | "pre-paginated";
+                    progressionWeight: number;
+                    pageSpreadLeft: true | undefined;
+                    pageSpreadRight: true | undefined;
+                    mediaType?: string | undefined;
+                };
+                load: () => void;
+                adjustPositionOfElement: ({ right, left, top }: {
+                    right?: number | undefined;
+                    left?: number | undefined;
+                    top?: number | undefined;
+                }) => void;
                 getElementDimensions: () => {
-                  width: number
-                  height: number
-                }
-                getHtmlFromResource: (response: Response) => Promise<string>
-                getResource: () => Promise<Response>
-                translateFramePositionIntoPage: (position: { clientX: number; clientY: number }) => {
-                  clientX: number
-                  clientY: number
-                }
-                setLayoutDirty: () => void
-                injectStyle: (cssText: string) => void
-                loadContent: () => void
-                unloadContent: () => void
+                    width: number;
+                    height: number;
+                };
+                getHtmlFromResource: (response: Response) => Promise<string>;
+                getResource: () => Promise<Response>;
+                translateFramePositionIntoPage: (position: {
+                    clientX: number;
+                    clientY: number;
+                }) => {
+                    clientX: number;
+                    clientY: number;
+                };
+                setLayoutDirty: () => void;
+                injectStyle: (cssText: string) => void;
+                loadContent: () => void;
+                unloadContent: () => void;
                 spineItemFrame: {
-                  getIsLoaded: () => boolean
-                  getIsReady: () => boolean
-                  getViewportDimensions: () =>
-                    | {
-                        width: number
-                        height: number
-                      }
-                    | undefined
-                  getFrameElement: () => HTMLIFrameElement | undefined
-                  getHtmlFromResource: (response: Response) => Promise<string>
-                  load: () => void
-                  unload: () => void
-                  staticLayout: (size: { width: number; height: number }) => void
-                  getManipulableFrame: () =>
-                    | {
-                        frame: HTMLIFrameElement
-                        removeStyle: (id: string) => void
-                        addStyle: (id: string, style: string, prepend?: boolean) => void
-                      }
-                    | undefined
-                  getReadingDirection: () => "ltr" | "rtl" | undefined
-                  isUsingVerticalWriting: () => boolean
-                  getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined
-                  destroy: () => void
-                  $: {
-                    unload$: import("rxjs").Observable<void>
-                    unloaded$: import("rxjs").Observable<void>
-                    loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                    ready$: import("rxjs").Observable<FontFaceSet | undefined>
-                    isReady$: import("rxjs").Observable<boolean>
-                    contentLayoutChange$: import("rxjs").Observable<
-                      | {
-                          isFirstLayout: boolean
-                        }
-                      | {
-                          isFirstLayout: boolean
-                        }
-                    >
-                  }
-                }
-                element: HTMLElement
-                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined
-                getViewPortInformation: () =>
-                  | {
-                      computedScale: number
-                      computedWidthScale: number
-                      viewportDimensions: {
-                        width: number
-                        height: number
-                      }
-                    }
-                  | undefined
-                isImageType: () => boolean
-                isReady: () => boolean
-                destroy: () => void
-                isUsingVerticalWriting: () => boolean | undefined
-                getReadingDirection: () => "ltr" | "rtl" | undefined
-                manipulateSpineItem: (
-                  cb: (
-                    options: {
-                      container: HTMLElement
-                      item: {
-                        id: string
-                        href: string
-                        renditionLayout: "reflowable" | "pre-paginated"
-                        progressionWeight: number
-                        pageSpreadLeft: true | undefined
-                        pageSpreadRight: true | undefined
-                        mediaType?: string | undefined
-                      }
-                      overlayElement: HTMLDivElement
-                    } & (
-                      | {
-                          frame: HTMLIFrameElement
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string, prepend?: boolean) => void
-                        }
-                      | {
-                          frame: undefined
-                          removeStyle: (id: string) => void
-                          addStyle: (id: string, style: string) => void
-                        }
-                    )
-                  ) => boolean
-                ) => boolean
-                executeOnLayoutBeforeMeasurementHook: (options: { minimumWidth: number }) => void
+                    getIsLoaded: () => boolean;
+                    getIsReady: () => boolean;
+                    getViewportDimensions: () => {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                    getFrameElement: () => HTMLIFrameElement | undefined;
+                    getHtmlFromResource: (response: Response) => Promise<string>;
+                    load: () => void;
+                    unload: () => void;
+                    staticLayout: (size: {
+                        width: number;
+                        height: number;
+                    }) => void;
+                    getManipulableFrame: () => {
+                        frame: HTMLIFrameElement;
+                        removeStyle: (id: string) => void;
+                        addStyle: (id: string, style: string, prepend?: boolean) => void;
+                    } | undefined;
+                    getReadingDirection: () => "ltr" | "rtl" | undefined;
+                    isUsingVerticalWriting: () => boolean;
+                    getWritingMode: () => "vertical-rl" | "horizontal-tb" | undefined;
+                    destroy: () => void;
+                    $: {
+                        unload$: import("rxjs").Observable<void>;
+                        unloaded$: import("rxjs").Observable<void>;
+                        loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                        ready$: import("rxjs").Observable<FontFaceSet | undefined>;
+                        isReady$: import("rxjs").Observable<boolean>;
+                        contentLayoutChange$: import("rxjs").Observable<{
+                            isFirstLayout: boolean;
+                        } | {
+                            isFirstLayout: boolean;
+                        }>;
+                    };
+                };
+                element: HTMLElement;
+                getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
+                getViewPortInformation: () => {
+                    computedScale: number;
+                    computedWidthScale: number;
+                    viewportDimensions: {
+                        width: number;
+                        height: number;
+                    };
+                } | undefined;
+                isImageType: () => boolean;
+                isReady: () => boolean;
+                destroy: () => void;
+                isUsingVerticalWriting: () => boolean | undefined;
+                getReadingDirection: () => "ltr" | "rtl" | undefined;
+                manipulateSpineItem: (cb: (options: {
+                    container: HTMLElement;
+                    item: {
+                        id: string;
+                        href: string;
+                        renditionLayout: "reflowable" | "pre-paginated";
+                        progressionWeight: number;
+                        pageSpreadLeft: true | undefined;
+                        pageSpreadRight: true | undefined;
+                        mediaType?: string | undefined;
+                    };
+                    overlayElement: HTMLDivElement;
+                } & ({
+                    frame: HTMLIFrameElement;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string, prepend?: boolean) => void;
+                } | {
+                    frame: undefined;
+                    removeStyle: (id: string) => void;
+                    addStyle: (id: string, style: string) => void;
+                })) => boolean) => boolean;
+                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
-                      }
-                  >
-                }
+                    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"
+                    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
-                }
+                            x: number;
+                            y: number;
+                        };
+                    } | {
+                        event: "fingerout";
+                        data: undefined;
+                    }>;
+                };
+                getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+                    columnHeight: number;
+                    columnWidth: number;
+                    width: number;
+                };
                 getDimensionsForPaginatedContent: () => {
-                  columnHeight: number
-                  columnWidth: number
-                }
+                    columnHeight: number;
+                    columnWidth: number;
+                };
                 $: {
-                  contentLayout$: import("rxjs").Observable<{
-                    isFirstLayout: boolean
-                    isReady: boolean
-                  }>
-                  loaded$: import("rxjs").Observable<HTMLIFrameElement>
-                  isReady$: import("rxjs").Observable<boolean>
-                }
-              }
-            | undefined
-        }
-    >
-  }
-}
+                    contentLayout$: import("rxjs").Observable<{
+                        isFirstLayout: boolean;
+                        isReady: boolean;
+                    }>;
+                    loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+                    isReady$: import("rxjs").Observable<boolean>;
+                };
+            } | undefined;
+        }>;
+    };
+};