@prose-reader/core 1.66.0 → 1.68.0

package/dist/{spineItemManager.d.ts → spine/locator/SpineLocator.d.ts}

@@ -1,14 +1,22 @@
-import { Context } from './context/Context';
-import { SpineItem } from './spineItem/createSpineItem';
-import { ReaderSettingsManager } from './settings/ReaderSettingsManager';
+import { Context } from '../../context/Context';
+import { SpineItem } from '../../spineItem/createSpineItem';
+import { createSpineItemLocator as createSpineItemLocator } from '../../spineItem/locationResolver';
+import { SpineItemsManager } from '../SpineItemsManager';
+import { SafeSpineItemPosition, UnsafeSpineItemPosition } from '../../spineItem/types';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
+import { getVisibleSpineItemsFromPosition } from './getVisibleSpineItemsFromPosition';
 
-export declare const createSpineItemManager: ({ context, settings, }: {
+export type SpineLocator = ReturnType<typeof createSpineLocator>;
+export declare const createSpineLocator: ({ spineItemsManager, context, spineItemLocator, settings, }: {
+    spineItemsManager: SpineItemsManager;
     context: Context;
+    spineItemLocator: ReturnType<typeof createSpineItemLocator>;
     settings: ReaderSettingsManager;
 }) => {
-    destroyItems: () => void;
-    add: (spineItem: SpineItem) => void;
-    get: (indexOrId: number | string) => {
+    getSpinePositionFromSpineItemPosition: (spineItemPosition: SafeSpineItemPosition, spineItem: SpineItem) => ViewportPosition;
+    getSpinePositionFromSpineItem: (spineItem: SpineItem) => ViewportPosition;
+    getSpineItemPositionFromSpinePosition: ((position: ViewportPosition, spineItem: SpineItem) => UnsafeSpineItemPosition) | ((position: ViewportPosition, spineItem: {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -20,13 +28,13 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         item: {
             id: string;
             href: string;
-            renditionLayout: `reflowable` | `pre-paginated`;
-            progressionWeight: number;
-            pageSpreadLeft: true | undefined;
-            pageSpreadRight: true | undefined;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
             mediaType?: string;
         };
-        load: () => void;
+        overlayElement: HTMLDivElement;
         adjustPositionOfElement: ({ right, left, top, }: {
             right?: number;
             left?: number;
@@ -35,6 +43,13 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         getElementDimensions: () => {
             width: number;
             height: number;
+            x: number;
+            y: number;
+            bottom: number;
+            left: number;
+            right: number;
+            top: number;
+            toJSON(): any;
         };
         getHtmlFromResource: (response: Response) => Promise<string>;
         getResource: () => Promise<Response>;
@@ -45,43 +60,10 @@ export declare const createSpineItemManager: ({ context, settings, }: {
             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: () => ReturnType<typeof import('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
-                }>;
-            };
-        };
+        load: () => void;
+        unload: () => void;
+        frame: import('../../spineItem/frame/FrameItem').FrameItem;
         element: HTMLElement;
         getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
         getViewPortInformation: () => {
@@ -95,17 +77,8 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         isImageType: () => boolean;
         isReady: () => boolean;
         destroy: () => void;
+        readingDirection: "ltr" | "rtl" | undefined;
         isUsingVerticalWriting: () => boolean | undefined;
-        getReadingDirection: () => "ltr" | "rtl" | undefined;
-        manipulateSpineItem: (cb: (options: {
-            container: HTMLElement;
-            item: import('@prose-reader/shared').Manifest[`spineItems`][number];
-            overlayElement: HTMLDivElement;
-        } & (ReturnType<typeof import('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | {
-            frame: undefined;
-            removeStyle: (id: string) => void;
-            addStyle: (id: string, style: string) => void;
-        })) => boolean) => boolean;
         executeOnLayoutBeforeMeasurementHook: (options: {
             minimumWidth: number;
         }) => void[];
@@ -160,8 +133,8 @@ export declare const createSpineItemManager: ({ context, settings, }: {
             loaded$: import('rxjs').Observable<HTMLIFrameElement>;
             isReady$: import('rxjs').Observable<boolean>;
         };
-    } | undefined;
-    getAll: () => {
+    }) => UnsafeSpineItemPosition);
+    getSpineItemFromPosition: (position: ViewportPosition) => {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -173,13 +146,13 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         item: {
             id: string;
             href: string;
-            renditionLayout: `reflowable` | `pre-paginated`;
-            progressionWeight: number;
-            pageSpreadLeft: true | undefined;
-            pageSpreadRight: true | undefined;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
             mediaType?: string;
         };
-        load: () => void;
+        overlayElement: HTMLDivElement;
         adjustPositionOfElement: ({ right, left, top, }: {
             right?: number;
             left?: number;
@@ -188,6 +161,13 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         getElementDimensions: () => {
             width: number;
             height: number;
+            x: number;
+            y: number;
+            bottom: number;
+            left: number;
+            right: number;
+            top: number;
+            toJSON(): any;
         };
         getHtmlFromResource: (response: Response) => Promise<string>;
         getResource: () => Promise<Response>;
@@ -198,43 +178,10 @@ export declare const createSpineItemManager: ({ context, settings, }: {
             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: () => ReturnType<typeof import('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
-                }>;
-            };
-        };
+        load: () => void;
+        unload: () => void;
+        frame: import('../../spineItem/frame/FrameItem').FrameItem;
         element: HTMLElement;
         getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
         getViewPortInformation: () => {
@@ -248,17 +195,8 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         isImageType: () => boolean;
         isReady: () => boolean;
         destroy: () => void;
+        readingDirection: "ltr" | "rtl" | undefined;
         isUsingVerticalWriting: () => boolean | undefined;
-        getReadingDirection: () => "ltr" | "rtl" | undefined;
-        manipulateSpineItem: (cb: (options: {
-            container: HTMLElement;
-            item: import('@prose-reader/shared').Manifest[`spineItems`][number];
-            overlayElement: HTMLDivElement;
-        } & (ReturnType<typeof import('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | {
-            frame: undefined;
-            removeStyle: (id: string) => void;
-            addStyle: (id: string, style: string) => void;
-        })) => boolean) => boolean;
         executeOnLayoutBeforeMeasurementHook: (options: {
             minimumWidth: number;
         }) => void[];
@@ -313,21 +251,8 @@ export declare const createSpineItemManager: ({ context, settings, }: {
             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]) => ReturnType<(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: () => {
+    } | undefined;
+    getSpineItemFromIframe: (iframe: Element) => {
         layout: ({ blankPagePosition, minimumWidth, spreadPosition, }: {
             blankPagePosition: `before` | `after` | `none`;
             minimumWidth: number;
@@ -339,13 +264,13 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         item: {
             id: string;
             href: string;
-            renditionLayout: `reflowable` | `pre-paginated`;
-            progressionWeight: number;
-            pageSpreadLeft: true | undefined;
-            pageSpreadRight: true | undefined;
+            renditionLayout?: `reflowable` | `pre-paginated`;
+            progressionWeight?: number;
+            pageSpreadLeft?: true | undefined;
+            pageSpreadRight?: true | undefined;
             mediaType?: string;
         };
-        load: () => void;
+        overlayElement: HTMLDivElement;
         adjustPositionOfElement: ({ right, left, top, }: {
             right?: number;
             left?: number;
@@ -354,6 +279,13 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         getElementDimensions: () => {
             width: number;
             height: number;
+            x: number;
+            y: number;
+            bottom: number;
+            left: number;
+            right: number;
+            top: number;
+            toJSON(): any;
         };
         getHtmlFromResource: (response: Response) => Promise<string>;
         getResource: () => Promise<Response>;
@@ -364,43 +296,10 @@ export declare const createSpineItemManager: ({ context, settings, }: {
             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: () => ReturnType<typeof import('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | 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;
-                }>;
-            };
-        };
+        load: () => void;
+        unload: () => void;
+        frame: import('../../spineItem/frame/FrameItem').FrameItem;
         element: HTMLElement;
         getBoundingRectOfElementFromSelector: (selector: string) => DOMRect | undefined;
         getViewPortInformation: () => {
@@ -414,17 +313,8 @@ export declare const createSpineItemManager: ({ context, settings, }: {
         isImageType: () => boolean;
         isReady: () => boolean;
         destroy: () => void;
+        readingDirection: "ltr" | "rtl" | undefined;
         isUsingVerticalWriting: () => boolean | undefined;
-        getReadingDirection: () => "ltr" | "rtl" | undefined;
-        manipulateSpineItem: (cb: (options: {
-            container: HTMLElement;
-            item: import('@prose-reader/shared').Manifest[`spineItems`][number];
-            overlayElement: HTMLDivElement;
-        } & (ReturnType<typeof import('./spineItem/frameItem/createFrameManipulator').createFrameManipulator> | {
-            frame: undefined;
-            removeStyle: (id: string) => void;
-            addStyle: (id: string, style: string) => void;
-        })) => boolean) => boolean;
         executeOnLayoutBeforeMeasurementHook: (options: {
             minimumWidth: number;
         }) => void[];
@@ -480,26 +370,47 @@ export declare const createSpineItemManager: ({ context, settings, }: {
             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;
-            };
-            isReady: boolean;
-        }>;
+    getSpineItemPageIndexFromNode: (node: Node, offset: number | undefined, spineItemOrIndex: SpineItem | number) => number | undefined;
+    getVisibleSpineItemsFromPosition: (params: Omit<Parameters<typeof getVisibleSpineItemsFromPosition>[0], "context" | "spineItemsManager" | "settings">) => {
+        beginIndex: number;
+        endIndex: number;
+    } | undefined;
+    getVisiblePagesFromViewportPosition: ({ position, threshold, spineItem, restrictToScreen, }: {
+        position: ViewportPosition;
+        threshold: number;
+        spineItem: SpineItem;
+        restrictToScreen?: boolean;
+    }) => {
+        beginPageIndex: number;
+        endPageIndex: number;
+    } | undefined;
+    isPositionWithinSpineItem: (position: ViewportPosition, spineItem: SpineItem) => boolean;
+    spineItemLocator: {
+        getSpineItemPositionFromNode: (node: Node, offset: number, spineItem: SpineItem) => {
+            x: number;
+            y: number;
+        } | undefined;
+        getSpineItemPositionFromPageIndex: (pageIndex: number, spineItem: SpineItem) => SafeSpineItemPosition;
+        getSpineItemPageIndexFromPosition: ({ itemWidth, itemHeight, position, isUsingVerticalWriting, }: {
+            itemWidth: number;
+            itemHeight: number;
+            position: UnsafeSpineItemPosition;
+            isUsingVerticalWriting: boolean;
+        }) => number;
+        getSpineItemPageIndexFromNode: (node: Node, offset: number, spineItem: SpineItem) => number | undefined;
+        getSpineItemClosestPositionFromUnsafePosition: (unsafePosition: UnsafeSpineItemPosition, spineItem: SpineItem) => {
+            x: number;
+            y: number;
+        };
+        getFirstNodeOrRangeAtPage: (pageIndex: number, spineItem: SpineItem) => {
+            node: Node;
+            offset: number;
+        } | undefined;
+        getSpineItemNumberOfPages: ({ itemHeight, itemWidth, isUsingVerticalWriting, }: {
+            itemWidth: number;
+            itemHeight: number;
+            isUsingVerticalWriting: boolean;
+        }) => number;
     };
+    getSafeSpineItemPositionFromUnsafeSpineItemPosition: (unsafePosition: UnsafeSpineItemPosition, spineItem: SpineItem) => SafeSpineItemPosition;
 };
-export type SpineItemManager = ReturnType<typeof createSpineItemManager>;

package/dist/spine/locator/getItemVisibilityForPosition.d.ts

@@ -0,0 +1,19 @@
+import { Context } from '../../context/Context';
+import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
+
+export declare const getItemVisibilityForPosition: ({ itemPosition: { bottom, left, right, top, width: itemWidth, height: itemHeight, }, threshold, viewportPosition, restrictToScreen, context, }: {
+    itemPosition: {
+        right: number;
+        left: number;
+        bottom: number;
+        top: number;
+        height: number;
+        width: number;
+    };
+    viewportPosition: ViewportPosition;
+    threshold: number;
+    restrictToScreen?: boolean;
+    context: Context;
+}) => {
+    visible: boolean;
+};

package/dist/spine/locator/getItemVisibilityForPosition.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/spine/locator/getSpineItemFromPosition.d.ts

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

package/dist/spine/locator/getVisibleSpineItemsFromPosition.d.ts

@@ -0,0 +1,16 @@
+import { Context } from '../../context/Context';
+import { ViewportPosition } from '../../navigation/viewport/ViewportNavigator';
+import { ReaderSettingsManager } from '../../settings/ReaderSettingsManager';
+import { SpineItemsManager } from '../SpineItemsManager';
+
+export declare const getVisibleSpineItemsFromPosition: ({ position, threshold, restrictToScreen, spineItemsManager, context, settings, }: {
+    position: ViewportPosition;
+    threshold: number;
+    restrictToScreen?: boolean;
+    spineItemsManager: SpineItemsManager;
+    context: Context;
+    settings: ReaderSettingsManager;
+}) => {
+    beginIndex: number;
+    endIndex: number;
+} | undefined;

package/dist/spine/locator/getVisibleSpineItemsFromPosition.test.d.ts

@@ -0,0 +1 @@
+export {};