@prose-reader/core 1.8.0 → 1.10.0

package/dist/enhancers/accessibility.d.ts

@@ -1,2 +1 @@
-import { Enhancer } from "./types";
-export declare const accessibilityEnhancer: Enhancer<{}, {}>;
+export declare const accessibilityEnhancer: <InheritOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/chrome.d.ts

@@ -1,2 +1 @@
-import { Enhancer } from "./types";
-export declare const chromeEnhancer: Enhancer<{}, {}>;
+export declare const chromeEnhancer: <InheritOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/fonts.d.ts

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

package/dist/enhancers/hotkeys.d.ts

@@ -1,2 +1 @@
-import { Enhancer } from "./types";
-export declare const hotkeysEnhancer: Enhancer<{}, {}>;
+export declare const hotkeysEnhancer: <InheritOptions extends import("../reader").CreateReaderOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

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

@@ -1,3 +1,3 @@
 import { Observable } from "rxjs";
-import { ReaderInstance } from "./types";
-export declare const createMovingSafePan$: (reader: ReaderInstance) => Observable<"free" | "busy" | undefined>;
+import { Reader } from "../../reader";
+export declare const createMovingSafePan$: (reader: Reader) => Observable<"free" | "busy" | undefined>;

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

@@ -1,2 +1,2 @@
-import { ReaderInstance } from "./types";
-export declare const fixReflowable: (reader: ReaderInstance) => void;
+import { Reader } from "../../reader";
+export declare const fixReflowable: (reader: Reader) => void;

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

@@ -1,2 +1,8 @@
-import { LayoutEnhancer } from "./types";
-export declare const layoutEnhancer: LayoutEnhancer;
+import { Observable, ObservedValueOf } from "rxjs";
+import { Options, SettingsInput, SettingsOutput } from "./types";
+export declare const layoutEnhancer: <InheritOptions extends import("../../reader").CreateReaderOptions, InheritOutput extends import("../../types").Reader, Settings$ extends Observable<any> = InheritOutput["settings$"]>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions & SettingsInput & {
+    layoutAutoResize?: false | "container" | undefined;
+}) => Omit<InheritOutput, "setSettings" | "settings$"> & {
+    settings$: Observable<ObservedValueOf<Settings$> & Required<SettingsInput>>;
+    setSettings: (settings: Parameters<InheritOutput["setSettings"]>[0] & SettingsInput) => void;
+};

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

@@ -1,10 +1,8 @@
-import { Enhancer } from "../types";
 export declare type SettingsInput = {
     pageHorizontalMargin?: number;
     pageVerticalMargin?: number;
 };
 export declare type SettingsOutput = Required<SettingsInput>;
-export declare type LayoutEnhancer = Enhancer<SettingsInput & {
+export declare type Options = SettingsInput & {
     layoutAutoResize?: `container` | false;
-}, {}, SettingsInput, SettingsOutput>;
-export declare type ReaderInstance = ReturnType<Parameters<LayoutEnhancer>[0]>;
+};

package/dist/enhancers/links.d.ts

@@ -1,12 +1,11 @@
 import { Observable } from "rxjs";
-import { Enhancer } from "./types";
 declare type SubjectData = {
     event: `linkClicked`;
     data: HTMLAnchorElement;
 };
-export declare const linksEnhancer: Enhancer<{}, {
+export declare const linksEnhancer: <InheritOptions extends import("../reader").CreateReaderOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
     $: {
         links$: Observable<SubjectData>;
     };
-}>;
+};
 export {};

package/dist/enhancers/loadingEnhancer.d.ts

@@ -1,21 +1,29 @@
 import { Observable } from "rxjs";
 import { Manifest } from "../types";
-import { themeEnhancer } from "./theme";
-import { Enhancer } from "./types";
 declare type Entries = {
     [key: string]: HTMLElement;
 };
 declare type Item = Manifest[`spineItems`][number];
-export declare const loadingEnhancer: Enhancer<{
+declare type Options = {
     loadingElementCreate?: (options: {
         container: HTMLElement;
         item: Item;
     }) => HTMLElement;
-}, {
+};
+declare type Output = {
     loading: {
         $: {
             items$: Observable<Entries>;
         };
     };
-}, {}, {}, typeof themeEnhancer>;
+};
+export declare const loadingEnhancer: <InheritOptions, InheritOutput extends import("../types").Reader & {
+    theme: {
+        set: (theme: import("./theme").Theme) => void;
+        get: () => import("./theme").Theme;
+        $: {
+            theme$: Observable<import("./theme").Theme>;
+        };
+    };
+}>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions & Options) => InheritOutput & Output;
 export {};

package/dist/enhancers/media.d.ts

@@ -1,2 +1 @@
-import { Enhancer } from "./types";
-export declare const mediaEnhancer: Enhancer<{}, {}>;
+export declare const mediaEnhancer: <InheritOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/navigation.d.ts

@@ -1,5 +1,4 @@
-import { Enhancer } from "./types";
-export declare const navigationEnhancer: Enhancer<{}, {
+export declare const navigationEnhancer: <InheritOptions extends import("../reader").CreateReaderOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
     goToLeftSpineItem: () => void;
     goToRightSpineItem: () => void;
-}>;
+};

package/dist/enhancers/pagination.d.ts

@@ -1,7 +1,5 @@
-import { Observable } from "rxjs";
-import { Enhancer } from "./types";
+import { Observable, ObservedValueOf } from "rxjs";
 import { Manifest } from "../types";
-import { progressionEnhancer } from "./progression";
 declare type ChapterInfo = {
     title: string;
     subChapter?: {
@@ -37,10 +35,355 @@ declare type PaginationInfo = {
     numberOfTotalPages: number | undefined;
     isUsingSpread: boolean;
 };
-export declare const paginationEnhancer: Enhancer<{}, {
-    $: {
-        pagination$: Observable<PaginationInfo>;
+export declare const paginationEnhancer: <InheritOptions, InheritOutput extends import("../types").Reader & {
+    progression: {
+        getPercentageEstimate: (context: import("../context").Context, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: {
+            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$: Observable<void>;
+                    unloaded$: Observable<void>;
+                    loaded$: Observable<HTMLIFrameElement>;
+                    ready$: Observable<FontFaceSet | undefined>;
+                    isReady$: Observable<boolean>;
+                    contentLayoutChange$: 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;
+                $: 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;
+                $: 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$: Observable<{
+                    isFirstLayout: boolean;
+                    isReady: boolean;
+                }>;
+                loaded$: Observable<HTMLIFrameElement>;
+                isReady$: Observable<boolean>;
+            };
+        }) => number;
+        getScrollPercentageWithinItem: (context: import("../context").Context, currentPosition: {
+            x: number;
+            y: number;
+        }, currentItem: {
+            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$: Observable<void>;
+                    unloaded$: Observable<void>;
+                    loaded$: Observable<HTMLIFrameElement>;
+                    ready$: Observable<FontFaceSet | undefined>;
+                    isReady$: Observable<boolean>;
+                    contentLayoutChange$: 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;
+                $: 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;
+                $: 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$: Observable<{
+                    isFirstLayout: boolean;
+                    isReady: boolean;
+                }>;
+                loaded$: Observable<HTMLIFrameElement>;
+                isReady$: Observable<boolean>;
+            };
+        }) => number;
     };
-}, {}, {}, typeof progressionEnhancer>;
+}, Pagination$ extends Observable<any> = InheritOutput["pagination$"]>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => Omit<InheritOutput, "pagination$"> & {
+    pagination$: Observable<ObservedValueOf<Pagination$> & PaginationInfo>;
+};
 export declare const buildChapterInfoFromSpineItem: (manifest: Manifest, item: Manifest[`spineItems`][number]) => ChapterInfo | undefined;
 export {};

package/dist/enhancers/progression.d.ts

@@ -1,7 +1,7 @@
 import { Context } from "../context";
-import { Enhancer } from "./types";
 import { SpineItem } from "../spineItem/createSpineItem";
-export declare const progressionEnhancer: Enhancer<{}, {
+import { Reader } from "../reader";
+export declare const progressionEnhancer: <InheritOptions, InheritOutput extends Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
     progression: {
         getPercentageEstimate: (context: Context, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
             x: number;
@@ -12,4 +12,4 @@ export declare const progressionEnhancer: Enhancer<{}, {
             y: number;
         }, currentItem: SpineItem) => number;
     };
-}>;
+};

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

@@ -1,2 +1 @@
-import { Enhancer } from "../types";
-export declare const resourcesEnhancer: Enhancer<{}, {}>;
+export declare const resourcesEnhancer: <InheritOptions, InheritOutput extends import("../../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/theme.d.ts

@@ -1,5 +1,4 @@
 import { Observable } from "rxjs";
-import { Enhancer } from "./types";
 declare const defaultThemes: ({
     name: "bright";
     backgroundColor: string;
@@ -13,10 +12,10 @@ declare const defaultThemes: ({
     backgroundColor: string;
     foregroundColor: string;
 })[];
-export declare type Theme = typeof defaultThemes[number][`name`] | `publisher`;
-export declare const themeEnhancer: Enhancer<{
-    theme?: Theme;
-}, {
+export declare type Theme = (typeof defaultThemes)[number][`name`] | `publisher`;
+export declare const themeEnhancer: <InheritOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions & {
+    theme?: Theme | undefined;
+}) => InheritOutput & {
     theme: {
         set: (theme: Theme) => void;
         get: () => Theme;
@@ -24,5 +23,5 @@ export declare const themeEnhancer: Enhancer<{
             theme$: Observable<Theme>;
         };
     };
-}>;
+};
 export {};

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

@@ -0,0 +1,5 @@
+export declare type EnhancerOutput<Enhancer extends (options: any) => any> = ReturnType<ReturnType<Enhancer>>;
+export declare type EnhancerOptions<Enhancer extends (options: any) => any> = Parameters<ReturnType<Enhancer>>[0];
+declare const rootEnhancer: <Options extends import("../../reader").CreateReaderOptions, Reader extends import("../../reader").Reader>(next: (options: Options) => Reader) => (options: Options) => Reader;
+export declare type RootEnhancer = typeof rootEnhancer;
+export {};

package/dist/enhancers/utils.d.ts

@@ -1,6 +1,5 @@
-import { Enhancer } from "./types";
-export declare const utilsEnhancer: Enhancer<{}, {
+export declare const utilsEnhancer: <InheritOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
     utils: {
         isOrIsWithinValidLink: (target: Event[`target`]) => boolean;
     };
-}>;
+};

package/dist/enhancers/webkit.d.ts

@@ -1,2 +1 @@
-import { Enhancer } from "./types";
-export declare const webkitEnhancer: Enhancer<{}, {}>;
+export declare const webkitEnhancer: <InheritOptions extends import("../reader").CreateReaderOptions, InheritOutput extends import("../types").Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput;

package/dist/enhancers/zoom/elementZoomer.d.ts

@@ -1,5 +1,5 @@
-import { ReaderInstance } from "./types";
-export declare const createElementZoomer: (reader: ReaderInstance) => {
+import { Reader } from "../../reader";
+export declare const createElementZoomer: (reader: Reader) => {
     enter: (imgElement: HTMLImageElement) => void;
     exit: () => void;
     move: (delta: {

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

@@ -1,2 +1,3 @@
-import { ZoomEnhancer } from "./types";
-export declare const zoomEnhancer: ZoomEnhancer;
+import { Reader } from "../../reader";
+import type { Api } from "./types";
+export declare const zoomEnhancer: <InheritOptions, InheritOutput extends Reader>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & Api;

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

@@ -1,8 +1,5 @@
 import { Observable } from "rxjs";
-import { Enhancer } from "../types";
-export declare type SettingsInput = {};
-export declare type SettingsOutput = Required<SettingsInput>;
-export declare type ZoomEnhancer = Enhancer<SettingsInput, {
+export declare type Api = {
     zoom: {
         enter: (imgElement?: HTMLImageElement) => void;
         exit: () => void;
@@ -22,5 +19,4 @@ export declare type ZoomEnhancer = Enhancer<SettingsInput, {
             isZooming$: Observable<boolean>;
         };
     };
-}, SettingsInput, SettingsOutput>;
-export declare type ReaderInstance = ReturnType<Parameters<ZoomEnhancer>[0]>;
+};

package/dist/enhancers/zoom/viewportZoomer.d.ts

@@ -1,5 +1,5 @@
-import { ReaderInstance } from "./types";
-export declare const createViewportZoomer: (reader: ReaderInstance) => {
+import { Reader } from "../../reader";
+export declare const createViewportZoomer: (reader: Reader) => {
     enter: () => void;
     exit: () => void;
     move: (_: {

package/dist/index.d.ts

@@ -1,11 +1,9 @@
-import { createReaderWithEnhancer as createReader } from "./createReaderWithEnhancer";
-import type { Reader, ExternalEnhancer as Enhancer, ReaderOptions } from "./createReaderWithEnhancer";
 import { createSelection } from "./selection";
 export { compose } from "./utils/compose";
-export type { ComposeEnhancer2, ComposeEnhancer3, ComposeEnhancer } from "./enhancers/composeEnhancer";
 export type { Manifest } from "./types";
-export { createReader, Reader, Enhancer, ReaderOptions };
+import { createReaderWithEnhancers } from "./createReaderWithEnhancer";
+export declare type Reader = ReturnType<typeof createReaderWithEnhancers>;
+export { createReaderWithEnhancers as createReader };
 export declare type ReaderSelection = ReturnType<typeof createSelection>;
 export { Report } from "./report";
-export { composeEnhancer } from "./enhancers/composeEnhancer";
 export { groupBy, isShallowEqual } from "./utils/objects";