@prose-reader/core 1.28.0 → 1.30.0

package/dist/spineItemManager.d.ts

@@ -1,636 +1,550 @@
-import { Context } from "./context"
-import { SpineItem } from "./spineItem/createSpineItem"
-export declare const createSpineItemManager: ({ context }: { context: Context }) => {
-  destroyItems: () => void
-  add: (spineItem: SpineItem) => void
-  get: (indexOrId: number | string) =>
-    | {
-        layout: ({
-          blankPagePosition,
-          minimumWidth,
-          spreadPosition,
-        }: {
-          blankPagePosition: "after" | "before" | "none"
-          minimumWidth: number
-          spreadPosition: "none" | "right" | "left"
+import { Context } from "./context";
+import { SpineItem } from "./spineItem/createSpineItem";
+export declare const createSpineItemManager: ({ context }: {
+    context: Context;
+}) => {
+    destroyItems: () => void;
+    add: (spineItem: SpineItem) => void;
+    get: (indexOrId: number | string) => {
+        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
-  getAll: () => {
-    layout: ({
-      blankPagePosition,
-      minimumWidth,
-      spreadPosition,
-    }: {
-      blankPagePosition: "after" | "before" | "none"
-      minimumWidth: number
-      spreadPosition: "none" | "right" | "left"
-    }) => {
-      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
-    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
-    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
-    selectionTracker: {
-      track: (frameToTrack: HTMLIFrameElement) => void
-      destroy: () => void
-      isSelecting: () => boolean
-      getSelection: () => Selection | undefined
-      $: import("rxjs").Observable<
-        | {
-            event: "selectionchange"
-            data: Selection | null
-          }
-        | {
-            event: "selectstart"
-            data: Selection | null
-          }
-        | {
-            event: "selectend"
-            data: Selection | null
-          }
-      >
-    }
-    fingerTracker: {
-      track: (frame: HTMLIFrameElement) => void
-      getFingerPositionInIframe():
-        | {
-            x: number | undefined
-            y: number | undefined
-          }
-        | undefined
-      destroy: () => void
-      $: import("rxjs").Observable<
-        | {
-            event: "fingermove"
-            data: {
-              x: number
-              y: number
-            }
-          }
-        | {
-            event: "fingerout"
-            data: undefined
-          }
-      >
-    }
-    getDimensionsForReflowableContent: (
-      isUsingVerticalWriting: boolean,
-      minimumWidth: number
-    ) => {
-      columnHeight: number
-      columnWidth: number
-      width: number
-    }
-    getDimensionsForPaginatedContent: () => {
-      columnHeight: number
-      columnWidth: number
-    }
-    $: {
-      contentLayout$: import("rxjs").Observable<{
-        isFirstLayout: boolean
-        isReady: boolean
-      }>
-      loaded$: import("rxjs").Observable<HTMLIFrameElement>
-      isReady$: import("rxjs").Observable<boolean>
-    }
-  }[]
-  getLength: () => number
-  layout: () => void
-  focus: (indexOrSpineItem: number | SpineItem) => void
-  loadContents: ((rangeOfIndex: [number, number]) => void) | ((rangeOfIndex: [number, number]) => void)
-  comparePositionOf: (toCompare: SpineItem, withItem: SpineItem) => "after" | "before"
-  getAbsolutePositionOf: (spineItemOrIndex: SpineItem | number) => {
-    left: number
-    right: number
-    top: number
-    bottom: number
-    width: number
-    height: number
-  }
-  getFocusedSpineItem: () =>
-    | {
-        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;
+    getAll: () => {
+        layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
+            blankPagePosition: "after" | "before" | "none";
+            minimumWidth: number;
+            spreadPosition: "none" | "right" | "left";
+        }) => {
+            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;
+        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;
+        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;
+        selectionTracker: {
+            track: (frameToTrack: HTMLIFrameElement) => void;
+            destroy: () => void;
+            isSelecting: () => boolean;
+            getSelection: () => Selection | undefined;
+            $: import("rxjs").Observable<{
+                event: "selectionchange";
+                data: Selection | null;
+            } | {
+                event: "selectstart";
+                data: Selection | null;
+            } | {
+                event: "selectend";
+                data: Selection | null;
+            }>;
+        };
+        fingerTracker: {
+            track: (frame: HTMLIFrameElement) => void;
+            getFingerPositionInIframe(): {
+                x: number | undefined;
+                y: number | undefined;
+            } | undefined;
+            destroy: () => void;
+            $: import("rxjs").Observable<{
+                event: "fingermove";
+                data: {
+                    x: number;
+                    y: number;
+                };
+            } | {
+                event: "fingerout";
+                data: undefined;
+            }>;
+        };
+        getDimensionsForReflowableContent: (isUsingVerticalWriting: boolean, minimumWidth: number) => {
+            columnHeight: number;
+            columnWidth: number;
+            width: number;
+        };
+        getDimensionsForPaginatedContent: () => {
+            columnHeight: number;
+            columnWidth: number;
+        };
+        $: {
+            contentLayout$: import("rxjs").Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+            isReady$: import("rxjs").Observable<boolean>;
+        };
+    }[];
+    getLength: () => number;
+    layout: () => void;
+    focus: (indexOrSpineItem: number | SpineItem) => void;
+    loadContents: ((rangeOfIndex: [number, number]) => void) | ((rangeOfIndex: [number, number]) => void);
+    comparePositionOf: (toCompare: SpineItem, withItem: SpineItem) => "after" | "before";
+    getAbsolutePositionOf: (spineItemOrIndex: SpineItem | number) => {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    getFocusedSpineItem: () => {
+        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
-  getFocusedSpineItemIndex: () => number | undefined
-  getSpineItemIndex: (spineItem: SpineItem | undefined) => number | undefined
-  destroy: () => void
-  $: {
-    focus$: import("rxjs").Observable<{
-      data: SpineItem
-    }>
-    layout$: import("rxjs").Observable<boolean>
-    itemIsReady$: import("rxjs").Observable<{
-      item: {
-        id: string
-        href: string
-        renditionLayout: "reflowable" | "pre-paginated"
-        progressionWeight: number
-        pageSpreadLeft: true | undefined
-        pageSpreadRight: true | undefined
-        mediaType?: string | undefined
-      }
-      isReady: boolean
-    }>
-  }
-}
-export type SpineItemManager = ReturnType<typeof createSpineItemManager>
+            contentLayout$: import("rxjs").Observable<{
+                isFirstLayout: boolean;
+                isReady: boolean;
+            }>;
+            loaded$: import("rxjs").Observable<HTMLIFrameElement>;
+            isReady$: import("rxjs").Observable<boolean>;
+        };
+    } | undefined;
+    getFocusedSpineItemIndex: () => number | undefined;
+    getSpineItemIndex: (spineItem: SpineItem | undefined) => number | undefined;
+    destroy: () => void;
+    $: {
+        focus$: import("rxjs").Observable<{
+            data: SpineItem;
+        }>;
+        layout$: import("rxjs").Observable<boolean>;
+        itemIsReady$: import("rxjs").Observable<{
+            item: {
+                id: string;
+                href: string;
+                renditionLayout: "reflowable" | "pre-paginated";
+                progressionWeight: number;
+                pageSpreadLeft: true | undefined;
+                pageSpreadRight: true | undefined;
+                mediaType?: string | undefined;
+            };
+            isReady: boolean;
+        }>;
+    };
+};
+export type SpineItemManager = ReturnType<typeof createSpineItemManager>;