@prose-reader/core 1.120.0 → 1.122.0

package/dist/cfi/CfiHandler.d.ts

@@ -35,7 +35,7 @@ export declare class CfiHandler {
         relativeToNode: string;
         offset: number;
     } | {
-        node: ChildNode | undefined;
+        node: ChildNode;
         offset: number;
         relativeToNode?: undefined;
     } | undefined;

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

@@ -6,10 +6,10 @@ export declare const resolveCfi: ({ cfi, spineItemsManager, }: {
     node: Node | undefined;
     offset: number | undefined;
     spineItemIndex: number;
-    spineItem: import('../../spineItem/SpineItem').SpineItem;
+    spineItem: import('../..').SpineItem;
 } | {
     spineItemIndex: number;
-    spineItem: import('../../spineItem/SpineItem').SpineItem;
+    spineItem: import('../..').SpineItem;
     node?: undefined;
     offset?: undefined;
 } | undefined;

package/dist/createReaderWithEnhancer.d.ts

@@ -29,16 +29,16 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
         };
         generateCfiForSpineItemPage: (params: {
             pageIndex: number;
-            spineItem: import('./spineItem/SpineItem').SpineItem;
+            spineItem: import('.').SpineItem;
         }) => string;
         resolveCfi: (params: Omit<Parameters<typeof import('./cfi/lookup/resolveCfi').resolveCfi>[0], "spineItemsManager">) => {
             node: Node | undefined;
             offset: number | undefined;
             spineItemIndex: number;
-            spineItem: import('./spineItem/SpineItem').SpineItem;
+            spineItem: import('.').SpineItem;
         } | {
             spineItemIndex: number;
-            spineItem: import('./spineItem/SpineItem').SpineItem;
+            spineItem: import('.').SpineItem;
             node?: undefined;
             offset?: undefined;
         } | undefined;
@@ -62,11 +62,11 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             getNavigationForSpineItemPage: (params: Omit<Parameters<typeof import('./navigation/resolvers/getNavigationForSpineItemPage').getNavigationForSpineItemPage>[0], "context" | "spineItemsManager" | "spineItemNavigationResolver" | "spineLocator">) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationFromSpineItemPosition: (params: {
                 spineItemPosition: import('./spineItem/types').UnsafeSpineItemPosition;
-                spineItem: import('./spineItem/SpineItem').SpineItem;
+                spineItem: import('.').SpineItem;
             }) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationForCfi: (cfi: string) => import('./navigation/viewport/ViewportNavigator').ViewportPosition | undefined;
-            getNavigationForLastPage: (spineItem: import('./spineItem/SpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
-            getNavigationForSpineIndexOrId: (indexOrId: number | string | import('./spineItem/SpineItem').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            getNavigationForLastPage: (spineItem: import('.').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
+            getNavigationForSpineIndexOrId: (indexOrId: number | string | import('.').SpineItem) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getMostPredominantNavigationForPosition: (viewportPosition: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             getAdjustedPositionWithSafeEdge: (position: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => {
@@ -84,9 +84,9 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             }) => boolean;
             getAdjustedPositionForSpread: (position: import('./navigation/viewport/ViewportNavigator').ViewportPosition) => import('./navigation/viewport/ViewportNavigator').ViewportPosition;
             spineItemNavigator: {
-                getNavigationForLastPage: (spineItem: import('./spineItem/SpineItem').SpineItem) => import('./spineItem/types').SafeSpineItemPosition;
-                getNavigationForPosition: (spineItem: import('./spineItem/SpineItem').SpineItem, position: import('./spineItem/types').UnsafeSpineItemPosition) => import('./spineItem/types').SafeSpineItemPosition;
-                getNavigationFromNode: (spineItem: import('./spineItem/SpineItem').SpineItem, node: Node, offset: number) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationForLastPage: (spineItem: import('.').SpineItem) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationForPosition: (spineItem: import('.').SpineItem, position: import('./spineItem/types').UnsafeSpineItemPosition) => import('./spineItem/types').SafeSpineItemPosition;
+                getNavigationFromNode: (spineItem: import('.').SpineItem, node: Node, offset: number) => import('./spineItem/types').SafeSpineItemPosition;
             };
         };
     };
@@ -123,11 +123,11 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
         getPercentageEstimate: (context: import('./context/Context').Context, currentSpineIndex: number, numberOfPages: number, pageIndex: number, currentPosition: {
             x: number;
             y: number;
-        }, currentItem: import('./spineItem/SpineItem').SpineItem) => number;
+        }, currentItem: import('.').SpineItem) => number;
         getScrollPercentageWithinItem: (context: import('./context/Context').Context, currentPosition: {
             x: number;
             y: number;
-        }, currentItem: import('./spineItem/SpineItem').SpineItem) => number;
+        }, currentItem: import('.').SpineItem) => number;
     };
 }, "pagination"> & {
     pagination: Omit<{
@@ -169,4 +169,31 @@ export declare const createReaderWithEnhancers: (options: Partial<import('./sett
             }>;
         };
     };
+} & {
+    selection: {
+        selection$: import('rxjs').Observable<{
+            document: Document;
+            selection: Selection;
+            itemId: string;
+        } | undefined>;
+        selectionStart$: import('rxjs').Observable<boolean>;
+        selectionEnd$: import('rxjs').Observable<void>;
+        selectionAfterPointerUp$: import('rxjs').Observable<[Event, {
+            document: Document;
+            selection: Selection;
+            itemId: string;
+        } | undefined]>;
+        lastSelectionOnPointerdown$: import('rxjs').Observable<({
+            document: Document;
+            selection: Selection;
+            itemId: string;
+        } | undefined) | undefined>;
+        generateCfis: (params: {
+            itemId: string;
+            selection: Selection;
+        }) => {
+            anchorCfi: string | undefined;
+            focusCfi: string | undefined;
+        };
+    };
 };

package/dist/enhancers/selection/SelectionTracker.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { DestroyableClass } from '../../utils/DestroyableClass';
+export declare class SelectionTracker extends DestroyableClass {
+    selectionChange$: Observable<Selection | null>;
+    selectionAfterPointerUp$: Observable<readonly [Event, Selection]>;
+    constructor(document: Document);
+}

package/dist/enhancers/selection/selection.d.ts

@@ -0,0 +1,7 @@
+export declare const generateCfis: ({ itemId, selection, }: {
+    selection: Selection;
+    itemId: string;
+}) => {
+    anchorCfi: string | undefined;
+    focusCfi: string | undefined;
+};

package/dist/enhancers/selection/selectionEnhancer.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { EnhancerOutput, RootEnhancer } from '../types/enhancer';
+type SelectionValue = {
+    document: Document;
+    selection: Selection;
+    itemId: string;
+} | undefined;
+export declare const selectionEnhancer: <InheritOptions, InheritOutput extends EnhancerOutput<RootEnhancer>>(next: (options: InheritOptions) => InheritOutput) => (options: InheritOptions) => InheritOutput & {
+    selection: {
+        selection$: Observable<SelectionValue>;
+        selectionStart$: Observable<boolean>;
+        selectionEnd$: Observable<void>;
+        selectionAfterPointerUp$: Observable<[Event, SelectionValue]>;
+        lastSelectionOnPointerdown$: Observable<SelectionValue | undefined>;
+        generateCfis: (params: {
+            itemId: string;
+            selection: Selection;
+        }) => {
+            anchorCfi: string | undefined;
+            focusCfi: string | undefined;
+        };
+    };
+};
+export {};

package/dist/hooks/types.d.ts

@@ -12,7 +12,7 @@ export type CoreHook = {
         layers: {
             element: HTMLElement;
         }[];
-    }) => void;
+    }) => Observable<void> | void;
 } | {
     name: `item.onDocumentLoad`;
     runFn: (params: {

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { createSelection } from './selection';
 import { createReaderWithEnhancers as createReader } from './createReaderWithEnhancer';
 export type { Manifest } from '@prose-reader/shared';
 export { DocumentRenderer } from './spineItem/DocumentRenderer';
@@ -7,8 +6,9 @@ export { HookManager } from './hooks/HookManager';
 export { SettingsManager } from './settings/SettingsManager';
 export type Reader = ReturnType<typeof createReader>;
 export { createReader };
-export type ReaderSelection = ReturnType<typeof createSelection>;
 export { Report } from './report';
 export { isHtmlElement } from './utils/dom';
 export { isShallowEqual } from './utils/objects';
 export { waitForSwitch } from './utils/rxjs';
+export { SpineItem } from './spineItem/SpineItem';
+export * from './utils/DestroyableClass';

package/dist/index.js

@@ -1,5 +1,5 @@
-import { takeUntil, Subject, combineLatest, map as map$1, switchMap, merge, EMPTY, fromEvent, withLatestFrom, NEVER, Observable, of, scheduled, animationFrameScheduler, take as take$1, from, distinctUntilChanged as distinctUntilChanged$1, tap as tap$1, throttleTime, finalize, startWith as startWith$1, debounceTime as debounceTime$1, BehaviorSubject, combineLatestWith, shareReplay as shareReplay$1, ReplaySubject, filter as filter$1, share, mergeMap, delay, identity, timer, skip as skip$1, exhaustMap, first as first$1, endWith, lastValueFrom, forkJoin, catchError as catchError$1 } from "rxjs";
-import { startWith, map, shareReplay, tap, pairwise, switchMap as switchMap$1, take, distinctUntilChanged, takeUntil as takeUntil$1, first, filter, debounceTime, skip, withLatestFrom as withLatestFrom$1, share as share$1, mergeMap as mergeMap$1, catchError } from "rxjs/operators";
+import { takeUntil, Subject, combineLatest, map as map$1, switchMap, merge, EMPTY, fromEvent, withLatestFrom, NEVER, Observable, of, scheduled, animationFrameScheduler, take as take$1, from, distinctUntilChanged as distinctUntilChanged$1, tap as tap$1, throttleTime, finalize, startWith as startWith$1, debounceTime as debounceTime$1, BehaviorSubject, combineLatestWith, shareReplay as shareReplay$1, ReplaySubject, filter as filter$1, share, mergeMap, delay as delay$1, identity, timer, skip as skip$1, exhaustMap, first as first$1, endWith, lastValueFrom, forkJoin, catchError as catchError$1 } from "rxjs";
+import { startWith, map, shareReplay, tap, pairwise, switchMap as switchMap$1, take, distinctUntilChanged, takeUntil as takeUntil$1, first, filter, delay, debounceTime, skip, withLatestFrom as withLatestFrom$1, share as share$1, mergeMap as mergeMap$1, catchError } from "rxjs/operators";
 import { shallowMergeIfDefined, isShallowEqual, detectMimeTypeFromName, parseContentType } from "@prose-reader/shared";
 import { isShallowEqual as isShallowEqual2 } from "@prose-reader/shared";
 const chromeEnhancer = (next) => (options) => {
@@ -518,14 +518,19 @@ const layoutEnhancer = (next) => (options) => {
       }
     });
   });
-  reader.hookManager.register(`item.onAfterLayout`, ({ item }) => {
-    const spineItem = reader.spineItemsManager.get(item.id);
-    if (spineItem == null ? void 0 : spineItem.isReady) {
-      spineItem == null ? void 0 : spineItem.renderer.layers.forEach(({ element }) => {
+  const revealItemOnReady$ = reader.spineItemsObserver.itemIsReady$.pipe(
+    filter(({ isReady }) => isReady),
+    /**
+     * Make sure that even if the document was loaded instantly, the layout is applied first
+     * and therefore the transition played. eg: pdf are loaded before attached to the dom.
+     */
+    delay(1, animationFrameScheduler),
+    tap(({ item }) => {
+      item.renderer.layers.forEach(({ element }) => {
         element.style.opacity = `1`;
       });
-    }
-  });
+    })
+  );
   const observeContainerResize = (container) => new Observable((observer) => {
     const resizeObserver = new ResizeObserver(() => {
       observer.next();
@@ -546,7 +551,6 @@ const layoutEnhancer = (next) => (options) => {
     })
   );
   const movingSafePan$ = createMovingSafePan$(reader);
-  movingSafePan$.subscribe();
   settingsManager.values$.pipe(
     mapKeysTo([`pageHorizontalMargin`, `pageVerticalMargin`]),
     distinctUntilChanged(isShallowEqual),
@@ -556,7 +560,7 @@ const layoutEnhancer = (next) => (options) => {
     }),
     takeUntil$1(reader.$.destroy$)
   ).subscribe();
-  merge(layoutOnContainerResize$).pipe(takeUntil$1(reader.$.destroy$)).subscribe();
+  merge(revealItemOnReady$, movingSafePan$, layoutOnContainerResize$).pipe(takeUntil$1(reader.$.destroy$)).subscribe();
   return {
     ...reader,
     destroy: () => {
@@ -3126,7 +3130,7 @@ class CfiHandler {
     let i, child;
     for (i = 0; i < children.length; i++) {
       child = children[i];
-      switch (child.nodeType) {
+      switch (child == null ? void 0 : child.nodeType) {
         case ELEMENT_NODE:
           if (cfiCount % 2 === 0) {
             cfiCount += 2;
@@ -3162,12 +3166,11 @@ class CfiHandler {
             cfiCount += 1;
           }
           if (cfiCount === index) {
-            const trueLength = this.trueLength(dom, child.textContent);
-            if (offset >= trueLength) {
-              offset -= trueLength;
-            } else {
+            const trueLength = this.trueLength(dom, child.textContent || "");
+            if (offset <= trueLength) {
               return { node: child, offset };
             }
+            offset -= trueLength;
           }
           lastChild = child;
           break;
@@ -3175,6 +3178,10 @@ class CfiHandler {
           continue;
       }
     }
+    if (lastChild && (lastChild.nodeType === TEXT_NODE || lastChild.nodeType === CDATA_SECTION_NODE)) {
+      const trueLength = this.trueLength(dom, lastChild.textContent || "");
+      return { node: lastChild, offset: Math.min(offset, trueLength) };
+    }
     if (index > cfiCount) {
       const o = { relativeToNode: `after`, offset: 0 };
       if (!lastChild) {
@@ -3701,7 +3708,7 @@ class ViewportNavigator extends DestroyableClass {
                  * anything for x ms while we effectively adjust. We want it to be immediate.
                  * However when user is repeatedly turning page, we can improve smoothness by delaying a bit the adjustment
                  */
-                currentEvent.shouldAnimate ? delay(1, animationFrameScheduler) : identity,
+                currentEvent.shouldAnimate ? delay$1(1, animationFrameScheduler) : identity,
                 tap$1((data) => {
                   const element2 = this.viewportElement$.getValue();
                   const noAdjustmentNeeded = false;
@@ -3737,7 +3744,7 @@ class ViewportNavigator extends DestroyableClass {
                     this.setViewportPosition(data.position);
                   }
                 }),
-                currentEvent.shouldAnimate ? delay(animationDuration / 2, animationFrameScheduler) : identity,
+                currentEvent.shouldAnimate ? delay$1(animationDuration / 2, animationFrameScheduler) : identity,
                 tap$1((data) => {
                   const element2 = this.viewportElement$.getValue();
                   if (pageTurnAnimation === `fade`) {
@@ -3745,7 +3752,7 @@ class ViewportNavigator extends DestroyableClass {
                     element2.style.setProperty(`opacity`, `1`);
                   }
                 }),
-                currentEvent.shouldAnimate ? delay(animationDuration / 2, animationFrameScheduler) : identity,
+                currentEvent.shouldAnimate ? delay$1(animationDuration / 2, animationFrameScheduler) : identity,
                 tap$1((data) => {
                   if (pageTurnAnimation === `fade`) {
                     this.setViewportPosition(data.position);
@@ -5958,83 +5965,6 @@ class SpineLayout extends DestroyableClass {
     this.layoutSubject.complete();
   }
 }
-const createFingerTracker = () => {
-  const fingerPositionInIframe = { x: void 0, y: void 0 };
-  const subject = new Subject();
-  let isMouseDown = false;
-  const track = (frame) => {
-    var _a, _b, _c;
-    fingerPositionInIframe.x = void 0;
-    fingerPositionInIframe.y = void 0;
-    (_a = frame.contentDocument) == null ? void 0 : _a.addEventListener(`mousedown`, (e) => {
-      isMouseDown = true;
-      fingerPositionInIframe.x = e.x;
-      fingerPositionInIframe.y = e.y;
-      subject.next({ event: `fingermove`, data: { x: e.x, y: e.y } });
-    });
-    (_b = frame.contentDocument) == null ? void 0 : _b.addEventListener(`mouseup`, () => {
-      isMouseDown = false;
-      fingerPositionInIframe.x = void 0;
-      fingerPositionInIframe.y = void 0;
-      subject.next({ event: `fingerout`, data: void 0 });
-    });
-    (_c = frame.contentDocument) == null ? void 0 : _c.addEventListener(`mousemove`, (e) => {
-      if (isMouseDown) {
-        subject.next({ event: `fingermove`, data: { x: e.x, y: e.y } });
-      }
-    });
-  };
-  return {
-    track,
-    getFingerPositionInIframe() {
-      return fingerPositionInIframe.x === void 0 || fingerPositionInIframe.y === void 0 ? void 0 : fingerPositionInIframe;
-    },
-    destroy: () => {
-    },
-    $: subject.asObservable()
-  };
-};
-const createSelectionTracker = () => {
-  let isSelecting = false;
-  let frame;
-  const subject = new Subject();
-  const mouseUpEvents = [`mouseup`, `pointerup`];
-  const track = (frameToTrack) => {
-    var _a, _b;
-    frame = frameToTrack;
-    mouseUpEvents.forEach((eventName) => {
-      var _a2;
-      (_a2 = frameToTrack.contentWindow) == null ? void 0 : _a2.addEventListener(eventName, () => {
-        isSelecting = false;
-      });
-    });
-    (_a = frameToTrack.contentDocument) == null ? void 0 : _a.addEventListener(`selectionchange`, () => {
-      var _a2;
-      subject.next({
-        event: `selectionchange`,
-        data: ((_a2 = frame == null ? void 0 : frame.contentWindow) == null ? void 0 : _a2.getSelection()) || null
-      });
-    });
-    (_b = frameToTrack.contentWindow) == null ? void 0 : _b.addEventListener(`selectstart`, () => {
-      isSelecting = true;
-    });
-  };
-  const destroy = () => {
-  };
-  return {
-    track,
-    destroy,
-    isSelecting: () => isSelecting,
-    getSelection: () => {
-      var _a;
-      const selection = (_a = frame == null ? void 0 : frame.contentWindow) == null ? void 0 : _a.getSelection();
-      if (!(selection == null ? void 0 : selection.anchorNode) || selection.type === `None` || selection.type === `Caret`)
-        return void 0;
-      return selection;
-    },
-    $: subject.asObservable()
-  };
-};
 class DocumentRenderer {
   constructor(context, settings, hookManager, item, containerElement, resourcesHandler) {
     this.context = context;
@@ -6065,9 +5995,6 @@ class DocumentRenderer {
     this.destroy$ = this.triggerSubject.pipe(
       filter$1((trigger) => trigger === `destroy`)
     );
-    this.stateSubject.subscribe((state) => {
-      console.log(`FOOO`, item.id, `state`, state);
-    });
     this.load$.pipe(
       switchMap(() => {
         this.stateSubject.next(`loading`);
@@ -6266,8 +6193,6 @@ class SpineItem {
     this.destroy = () => {
       this.destroySubject$.next();
       this.containerElement.remove();
-      this.fingerTracker.destroy();
-      this.selectionTracker.destroy();
       this.destroySubject$.complete();
       this.renderer.destroy();
     };
@@ -6281,8 +6206,6 @@ class SpineItem {
       item,
       hookManager
     );
-    this.fingerTracker = createFingerTracker();
-    this.selectionTracker = createSelectionTracker();
     parentElement.appendChild(this.containerElement);
     const RendererClass = ((_b = (_a = this.settings.values).getRenderer) == null ? void 0 : _b.call(_a, item)) ?? DefaultRenderer;
     this.resourcesHandler = new ResourceHandler(item, this.settings);
@@ -6445,15 +6368,6 @@ class Spine extends DestroyableClass {
   layout() {
     this.spineLayout.layout();
   }
-  isSelecting() {
-    return this.spineItemsManager.items.some(
-      (item) => item.selectionTracker.isSelecting()
-    );
-  }
-  getSelection() {
-    var _a;
-    return (_a = this.spineItemsManager.items.find((item) => item.selectionTracker.getSelection())) == null ? void 0 : _a.selectionTracker.getSelection();
-  }
   destroy() {
     super.destroy();
     this.spineItemsLoader.destroy();
@@ -7424,8 +7338,6 @@ const eventsEnhancer = (next) => (options) => {
           (_a3 = frame.contentDocument) == null ? void 0 : _a3.removeEventListener(event, listener);
         };
       });
-      item.selectionTracker.track(frame);
-      item.fingerTracker.track(frame);
       destroy(() => {
         unregister.forEach((cb) => cb());
       });
@@ -8199,28 +8111,158 @@ const htmlEnhancer = (next) => (options) => {
   });
   return reader;
 };
+const generateCfis = ({
+  itemId,
+  selection
+}) => {
+  const anchorCfi = selection.anchorNode ? CfiHandler.generate(
+    selection.anchorNode,
+    selection.anchorOffset,
+    `|[prose~anchor~${encodeURIComponent(itemId)}]`
+  ) : void 0;
+  const focusCfi = selection.focusNode ? CfiHandler.generate(
+    selection.focusNode,
+    selection.focusOffset,
+    `|[prose~anchor~${encodeURIComponent(itemId)}]`
+  ) : void 0;
+  return {
+    anchorCfi,
+    focusCfi
+  };
+};
+class SelectionTracker extends DestroyableClass {
+  constructor(document2) {
+    super();
+    this.selectionChange$ = fromEvent(document2, "selectionchange").pipe(
+      map$1(() => document2.getSelection())
+    );
+    this.selectionAfterPointerUp$ = fromEvent(document2, "pointerup").pipe(
+      /**
+       * The selection is still valid during the event even if it will
+       * be discarded. The timeout make sure to detect this edge case.
+       */
+      delay$1(0),
+      map$1((event) => {
+        const selection = document2.getSelection();
+        return selection && !selection.isCollapsed ? [event, selection] : void 0;
+      }),
+      filter$1(isDefined)
+    );
+  }
+}
+const selectionEnhancer = (next) => (options) => {
+  const reader = next(options);
+  const selectionSubject = new BehaviorSubject(
+    void 0
+  );
+  const selectionWithPointerUpSubject = new Subject();
+  reader.hookManager.register(
+    `item.onDocumentLoad`,
+    ({ itemId, layers, destroy$, destroy }) => {
+      var _a, _b;
+      const frame = (_a = layers[0]) == null ? void 0 : _a.element;
+      if (frame instanceof HTMLIFrameElement) {
+        const frameDoc = frame.contentDocument || ((_b = frame.contentWindow) == null ? void 0 : _b.document);
+        if (frameDoc) {
+          const selectionTracker = new SelectionTracker(frameDoc);
+          merge(
+            selectionTracker.selectionChange$.pipe(
+              tap$1((selection) => {
+                if (selection == null ? void 0 : selection.toString()) {
+                  selectionSubject.next({
+                    document: frameDoc,
+                    selection,
+                    itemId
+                  });
+                } else {
+                  selectionSubject.next(void 0);
+                }
+              })
+            ),
+            selectionTracker.selectionAfterPointerUp$.pipe(
+              tap$1(([event, selection]) => {
+                selectionWithPointerUpSubject.next([
+                  event,
+                  {
+                    document: frameDoc,
+                    selection,
+                    itemId
+                  }
+                ]);
+              })
+            )
+          ).pipe(takeUntil(destroy$)).subscribe();
+          destroy(() => {
+            selectionTracker.destroy();
+          });
+        }
+      }
+    }
+  );
+  const selection$ = selectionSubject.pipe(
+    distinctUntilChanged$1(),
+    shareReplay$1(1),
+    takeUntil(reader.$.destroy$)
+  );
+  const selectionStart$ = selectionSubject.pipe(
+    map$1((selection) => !!selection),
+    distinctUntilChanged$1(),
+    filter$1((isSelecting) => isSelecting),
+    share()
+  );
+  const selectionEnd$ = selectionStart$.pipe(
+    switchMap(() => selection$),
+    distinctUntilChanged$1(),
+    filter$1((selection) => !selection),
+    share()
+  );
+  const selectionAfterPointerUp$ = selectionWithPointerUpSubject.asObservable();
+  const lastSelectionOnPointerdown$ = reader.context.containerElement$.pipe(
+    switchMap((container) => fromEvent(container, "pointerdown")),
+    withLatestFrom(selection$),
+    map$1(([, selection]) => selection),
+    startWith$1(void 0)
+  );
+  return {
+    ...reader,
+    selection: {
+      selection$,
+      selectionStart$,
+      selectionEnd$,
+      selectionAfterPointerUp$,
+      lastSelectionOnPointerdown$,
+      generateCfis
+    },
+    destroy: () => {
+      selectionSubject.complete();
+      reader.destroy();
+    }
+  };
+};
 const createReaderWithEnhancers = (
   //__
-  hotkeysEnhancer(
-    loadingEnhancer(
-      webkitEnhancer(
-        fontsEnhancer(
-          linksEnhancer(
-            accessibilityEnhancer(
-              resourcesEnhancer(
-                utilsEnhancer(
-                  layoutEnhancer(
-                    zoomEnhancer(
-                      mediaEnhancer(
-                        chromeEnhancer(
-                          navigationEnhancer(
-                            themeEnhancer(
-                              paginationEnhancer(
-                                progressionEnhancer(
-                                  eventsEnhancer(
-                                    htmlEnhancer(
-                                      // __
-                                      createReader
+  selectionEnhancer(
+    hotkeysEnhancer(
+      loadingEnhancer(
+        webkitEnhancer(
+          fontsEnhancer(
+            linksEnhancer(
+              accessibilityEnhancer(
+                resourcesEnhancer(
+                  utilsEnhancer(
+                    layoutEnhancer(
+                      zoomEnhancer(
+                        mediaEnhancer(
+                          chromeEnhancer(
+                            navigationEnhancer(
+                              themeEnhancer(
+                                paginationEnhancer(
+                                  progressionEnhancer(
+                                    eventsEnhancer(
+                                      htmlEnhancer(
+                                        // __
+                                        createReader
+                                      )
                                     )
                                   )
                                 )
@@ -8241,11 +8283,13 @@ const createReaderWithEnhancers = (
   )
 );
 export {
+  DestroyableClass,
   DocumentRenderer,
   HookManager,
   Report,
   ResourceHandler,
   SettingsManager3 as SettingsManager,
+  SpineItem,
   createReaderWithEnhancers as createReader,
   isHtmlElement,
   isShallowEqual2 as isShallowEqual,