@recogito/text-annotator 3.0.0-rc.5 → 3.0.0-rc.51

package/dist/src/SelectionHandler.d.ts

@@ -1,7 +1,8 @@
-import { type User } from '@annotorious/core';
-import type { TextAnnotatorState } from './state';
-import type { TextSelector } from './model';
-export declare const rangeToSelector: (range: Range, container: HTMLElement, offsetReferenceSelector?: string) => TextSelector;
-export declare const SelectionHandler: (container: HTMLElement, state: TextAnnotatorState, offsetReferenceSelector?: string) => {
-    setUser: (user: User) => User;
+import { Filter, User } from '@annotorious/core';
+import { TextAnnotatorState } from './state';
+import { TextAnnotation } from './model';
+export declare const SelectionHandler: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, annotatingEnabled: boolean, offsetReferenceSelector?: string) => {
+    destroy: () => void;
+    setFilter: (filter?: Filter) => Filter;
+    setUser: (user?: User) => User;
 };

package/dist/src/TextAnnotator.d.ts

@@ -1,8 +1,12 @@
-import type { Annotator } from '@annotorious/core';
-import type { TextAnnotation } from './model';
-import type { TextAnnotatorOptions } from './TextAnnotatorOptions';
-export interface TextAnnotator<T extends unknown = TextAnnotation> extends Annotator<TextAnnotation, T> {
+import { Annotator } from '@annotorious/core';
+import { HighlightStyleExpression } from './highlight';
+import { TextAnnotatorState } from './state';
+import { TextAnnotation } from './model';
+import { TextAnnotatorOptions } from './TextAnnotatorOptions';
+export interface TextAnnotator<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Annotator<I, E> {
     element: HTMLElement;
-    scrollIntoView(annotation: TextAnnotation): boolean;
+    setStyle(style: HighlightStyleExpression | undefined): void;
+    scrollIntoView(annotationOrId: I | string): boolean;
+    state: TextAnnotatorState<I, E>;
 }
-export declare const createTextAnnotator: <E extends unknown = TextAnnotation>(container: HTMLElement, opts?: TextAnnotatorOptions<E>) => TextAnnotator<E>;
+export declare const createTextAnnotator: <E extends unknown = TextAnnotation>(container: HTMLElement, options?: TextAnnotatorOptions<TextAnnotation, E>) => TextAnnotator<TextAnnotation, E>;

package/dist/src/TextAnnotatorOptions.d.ts

@@ -1,10 +1,16 @@
-import type { DrawingStyle, FormatAdapter, PointerSelectAction } from '@annotorious/core';
-import type { PresencePainterOptions } from './presence';
-import type { TextAnnotation } from './model';
-export interface TextAnnotatorOptions<T extends unknown = TextAnnotation> {
-    adapter?: FormatAdapter<TextAnnotation, T> | null;
+import { FormatAdapter, UserSelectActionExpression, User } from '@annotorious/core';
+import { PresencePainterOptions } from './presence';
+import { TextAnnotation } from './model';
+import { HighlightStyleExpression } from './highlight';
+export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> {
+    adapter?: FormatAdapter<I, E> | null;
+    annotatingEnabled?: boolean;
+    renderer?: RendererType;
     offsetReferenceSelector?: string;
-    pointerAction?: PointerSelectAction | ((annotation: TextAnnotation) => PointerSelectAction);
+    userSelectAction?: UserSelectActionExpression<E>;
     presence?: PresencePainterOptions;
-    style?: DrawingStyle | ((annotation: TextAnnotation) => DrawingStyle);
+    style?: HighlightStyleExpression;
+    user?: User;
 }
+export type RendererType = 'SPANS' | 'CANVAS' | 'CSS_HIGHLIGHTS';
+export declare const fillDefaults: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(opts: TextAnnotatorOptions<I, E>, defaults: TextAnnotatorOptions<I, E>) => TextAnnotatorOptions<I, E>;

package/dist/src/api/scrollIntoView.d.ts

@@ -1,3 +1,3 @@
-import type { TextAnnotationStore } from 'src/state';
-import type { TextAnnotation } from '../model/TextAnnotation';
-export declare const scrollIntoView: (container: HTMLElement, store: TextAnnotationStore) => (annotation: TextAnnotation) => boolean;
+import { TextAnnotationStore } from '../state';
+import { TextAnnotation } from '../model';
+export declare const scrollIntoView: (container: HTMLElement, store: TextAnnotationStore) => (annotationOrId: string | TextAnnotation) => boolean;

package/dist/src/highlight/Highlight.d.ts

@@ -0,0 +1,5 @@
+import { AnnotationState } from '@annotorious/core';
+import { AnnotationRects } from '../state';
+export interface Highlight extends AnnotationRects {
+    state: AnnotationState;
+}

package/dist/src/highlight/HighlightPainter.d.ts

@@ -1,20 +1,11 @@
-import type { DrawingStyle } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
-import type { Rect } from '../state';
-/**
- * A painter implements the actual CANVAS highlight drawing logic.
- */
-export type HighlightPainter = {
-    paint(annotation: TextAnnotation, rects: Rect[], bg: CanvasRenderingContext2D, fg: CanvasRenderingContext2D, isSelected?: boolean, style?: DrawingStyle | ((annotation: TextAnnotation, selected?: boolean) => DrawingStyle)): void;
-};
-/**
- * The default painter.
- */
-export declare const defaultPainter: HighlightPainter;
-export interface HighlightStyle {
-    fill?: string;
-    fillOpacity?: number;
-    underline?: string;
-    underlineOpacity?: number;
-    underlineWidth?: number;
+import { Highlight } from './Highlight';
+import { HighlightStyle, HighlightStyleExpression } from './HighlightStyle';
+import { ViewportBounds } from './viewport';
+export interface HighlightPainter {
+    clear(): void;
+    destroy(): void;
+    paint(highlight: Highlight, viewportBounds: ViewportBounds): HighlightStyle;
+    reset(): void;
 }
+/** Helper **/
+export declare const paint: (highlight: Highlight, viewportBounds: ViewportBounds, style?: HighlightStyleExpression, painter?: HighlightPainter, zIndex?: number) => HighlightStyle;

package/dist/src/highlight/HighlightStyle.d.ts

@@ -0,0 +1,11 @@
+import { AnnotationState, Color, DrawingStyle } from '@annotorious/core';
+import { TextAnnotation } from 'src/model';
+export interface HighlightStyle extends Pick<DrawingStyle, 'fill' | 'fillOpacity'> {
+    underlineStyle?: string;
+    underlineColor?: Color;
+    underlineOffset?: number;
+    underlineThickness?: number;
+}
+export type HighlightStyleExpression = HighlightStyle | ((annotation: TextAnnotation, state: AnnotationState, zIndex?: number) => HighlightStyle | undefined);
+export declare const DEFAULT_STYLE: HighlightStyle;
+export declare const DEFAULT_SELECTED_STYLE: HighlightStyle;

package/dist/src/highlight/baseRenderer.d.ts

@@ -0,0 +1,20 @@
+import { Filter, ViewportState } from '@annotorious/core';
+import { TextAnnotatorState } from '../state';
+import { ViewportBounds } from './viewport';
+import { HighlightPainter } from './HighlightPainter';
+import { Highlight } from './Highlight';
+import { HighlightStyleExpression } from './HighlightStyle';
+export interface RendererImplementation {
+    destroy(): void;
+    redraw(highlights: Highlight[], bounds: ViewportBounds, style?: HighlightStyleExpression, painter?: HighlightPainter, lazy?: boolean): void;
+    setVisible(visible: boolean): void;
+}
+export interface Renderer {
+    destroy(): void;
+    redraw(force?: boolean): void;
+    setStyle(style?: HighlightStyleExpression): void;
+    setFilter(filter?: Filter): void;
+    setPainter(painter?: HighlightPainter): void;
+    setVisible(visible: boolean): void;
+}
+export declare const createBaseRenderer: <T extends TextAnnotatorState = TextAnnotatorState<import('..').TextAnnotation, import('..').TextAnnotation>>(container: HTMLElement, state: T, viewport: ViewportState, renderer: RendererImplementation) => Renderer;

package/dist/src/highlight/canvas/canvasRenderer.d.ts

@@ -0,0 +1,4 @@
+import { ViewportState } from '@annotorious/core';
+import { TextAnnotatorState } from '../../state';
+import { TextAnnotation } from 'src/model';
+export declare const createCanvasRenderer: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => import('../baseRenderer').Renderer;

package/dist/src/highlight/canvas/index.d.ts

@@ -0,0 +1 @@
+export * from './canvasRenderer';

package/dist/src/highlight/highlights/highlightsRenderer.d.ts

@@ -0,0 +1,6 @@
+import { ViewportState } from '@annotorious/core';
+import { TextAnnotatorState } from 'src/state';
+import { RendererImplementation } from '../baseRenderer';
+import { TextAnnotation } from 'src/model';
+export declare const createRenderer: () => RendererImplementation;
+export declare const createHighlightsRenderer: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => import('../baseRenderer').Renderer;

package/dist/src/highlight/highlights/index.d.ts

@@ -0,0 +1 @@
+export * from './highlightsRenderer';

package/dist/src/highlight/index.d.ts

@@ -1,2 +1,6 @@
-export * from './highlightLayer';
+export * from './Highlight';
+export * from './HighlightStyle';
 export * from './HighlightPainter';
+export * from './canvas';
+export * from './highlights';
+export * from './span';

package/dist/src/highlight/span/index.d.ts

@@ -0,0 +1 @@
+export * from './spansRenderer';

package/dist/src/highlight/span/spansRenderer.d.ts

@@ -0,0 +1,4 @@
+import { ViewportState } from '@annotorious/core';
+import { TextAnnotatorState } from '../../state';
+import { TextAnnotation } from 'src/model';
+export declare const createSpansRenderer: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => import('../baseRenderer').Renderer;

package/dist/src/highlight/viewport.d.ts

@@ -0,0 +1,12 @@
+import { ViewportState } from '@annotorious/core';
+import { TextAnnotation } from '../model';
+export interface ViewportBounds {
+    top: number;
+    left: number;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export declare const getViewportBounds: (container: HTMLElement) => ViewportBounds;
+export declare const trackViewport: (viewport: ViewportState) => (annotations: TextAnnotation[]) => void;

package/dist/src/index.d.ts

@@ -1,8 +1,11 @@
+export * from './api';
 export * from './highlight';
 export * from './model';
 export * from './state';
-export * from './presence/PresencePainterOptions';
+export * from './utils';
+export * from './presence';
+export * from './SelectionHandler';
 export * from './TextAnnotator';
 export * from './TextAnnotatorOptions';
-import { Origin as _Origin } from '@annotorious/core';
-export { _Origin as Origin };
+export type { Annotation, AnnotationBody, AnnotationTarget, Annotator, AnnotatorState, Color, Filter, FormatAdapter, HoverState, Selection, SelectionState, Store, StoreChangeEvent, StoreObserver, ParseResult, User, UserSelectActionExpression, ViewportState, W3CAnnotation, W3CAnnotationBody, W3CAnnotationTarget } from '@annotorious/core';
+export { createBody, Origin, UserSelectAction } from '@annotorious/core';

package/dist/src/model/{TextAnnotation.d.ts → core/TextAnnotation.d.ts}

@@ -1,11 +1,12 @@
-import type { Annotation, AnnotationTarget } from '@annotorious/core';
+import { Annotation, AnnotationTarget } from '@annotorious/core';
 export interface TextAnnotation extends Annotation {
     target: TextAnnotationTarget;
 }
 export interface TextAnnotationTarget extends AnnotationTarget {
-    selector: TextSelector;
+    selector: TextSelector[];
 }
 export interface TextSelector {
+    id?: string;
     quote: string;
     start: number;
     end: number;

package/dist/src/model/core/index.d.ts

@@ -0,0 +1 @@
+export * from './TextAnnotation';

package/dist/src/model/index.d.ts

@@ -1 +1,2 @@
-export * from './TextAnnotation';
+export * from './core';
+export * from './w3c';

package/dist/src/model/w3c/W3CTextAnnotation.d.ts

@@ -0,0 +1,34 @@
+import { W3CAnnotation, W3CAnnotationTarget } from '@annotorious/core';
+export interface W3CTextAnnotation extends W3CAnnotation {
+    target: W3CTextAnnotationTarget | W3CTextAnnotationTarget[];
+    stylesheet?: W3CAnnotationStylesheet;
+}
+export interface W3CTextAnnotationTarget extends W3CAnnotationTarget {
+    selector: W3CTextSelector | W3CTextSelector[];
+    styleClass?: string;
+    scope?: string;
+}
+/**
+ * Matches the `Text Quote Selector` spec
+ * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
+ */
+export interface W3CTextQuoteSelector {
+    type: 'TextQuoteSelector';
+    exact: string;
+    prefix?: string;
+    suffix?: string;
+}
+/**
+ * Matches the `Text Position Selector` spec
+ * @see https://www.w3.org/TR/annotation-model/#text-position-selector
+ */
+export interface W3CTextPositionSelector {
+    type: 'TextPositionSelector';
+    start: number;
+    end: number;
+}
+export type W3CTextSelector = W3CTextQuoteSelector | W3CTextPositionSelector;
+export type W3CAnnotationStylesheet = string | {
+    type: 'CssStylesheet';
+    value: string;
+};

package/dist/src/model/w3c/W3CTextFormatAdapter.d.ts

@@ -0,0 +1,12 @@
+import { FormatAdapter, ParseResult } from '@annotorious/core';
+import { TextAnnotation } from '../core';
+import { W3CTextAnnotation } from '../w3c';
+export type W3CTextFormatAdapter = FormatAdapter<TextAnnotation, W3CTextAnnotation>;
+/**
+ * @param source - the IRI of the annotated content
+ * @param container - the HTML container of the annotated content,
+ *                    Required to locate the content's `range` within the DOM
+ */
+export declare const W3CTextFormat: (source: string, container: HTMLElement) => W3CTextFormatAdapter;
+export declare const parseW3CTextAnnotation: (annotation: W3CTextAnnotation) => ParseResult<TextAnnotation>;
+export declare const serializeW3CTextAnnotation: (annotation: TextAnnotation, source: string, container: HTMLElement) => W3CTextAnnotation;

package/dist/src/model/w3c/index.d.ts

@@ -0,0 +1,2 @@
+export * from './W3CTextAnnotation';
+export * from './W3CTextFormatAdapter';

package/dist/src/presence/PresencePainter.d.ts

@@ -1,4 +1,4 @@
-import type { PresenceProvider } from '@annotorious/core';
-import type { HighlightPainter } from '../highlight';
-import type { PresencePainterOptions } from './PresencePainterOptions';
-export declare const createPainter: (provider: PresenceProvider, opts?: PresencePainterOptions) => HighlightPainter;
+import { PresenceProvider } from '@annotorious/core';
+import { HighlightPainter } from '../highlight';
+import { PresencePainterOptions } from '../presence';
+export declare const createPresencePainter: (provider: PresenceProvider, opts?: PresencePainterOptions) => HighlightPainter;

package/dist/src/state/TextAnnotationStore.d.ts

@@ -1,16 +1,17 @@
-import type { Origin, Store } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
-export interface TextAnnotationStore extends Omit<Store<TextAnnotation>, 'addAnnotation' | 'bulkAddAnnotation'> {
-    addAnnotation(annotation: TextAnnotation, origin: Origin): boolean;
-    bulkAddAnnotation(annotations: TextAnnotation[], replace: boolean, origin: Origin): TextAnnotation[];
+import { Filter, Origin, Store } from '@annotorious/core';
+import { TextAnnotation } from '../model';
+export interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotation'> {
+    addAnnotation(annotation: T, origin?: Origin): boolean;
+    bulkAddAnnotation(annotations: T[], replace: boolean, origin?: Origin): T[];
+    bulkUpsertAnnotations(annotations: T[], origin?: Origin): T[];
     getAnnotationBounds(id: string, hintX?: number, hintY?: number, buffer?: number): DOMRect;
-    getAt(x: number, y: number): TextAnnotation | undefined;
-    getIntersecting(minX: number, minY: number, maxX: number, maxY: number): TextAnnotation[];
-    getIntersectingRects(minX: number, minY: number, maxX: number, maxY: number): AnnotationRects[];
+    getAnnotationRects(id: string): DOMRect[];
+    getAt(x: number, y: number, filter?: Filter): T | undefined;
+    getIntersecting(minX: number, minY: number, maxX: number, maxY: number): AnnotationRects<T>[];
     recalculatePositions(): void;
 }
-export interface AnnotationRects {
-    annotation: TextAnnotation;
+export interface AnnotationRects<T extends TextAnnotation = TextAnnotation> {
+    annotation: T;
     rects: Rect[];
 }
 export interface Rect {

package/dist/src/state/TextAnnotatorState.d.ts

@@ -1,11 +1,10 @@
-import type { PointerSelectAction, ViewportState } from '@annotorious/core';
-import { AnnotatorState, SelectionState, HoverState } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
-import type { TextAnnotationStore } from './TextAnnotationStore';
-export type TextAnnotatorState = AnnotatorState<TextAnnotation> & {
-    store: TextAnnotationStore;
-    selection: SelectionState<TextAnnotation>;
-    hover: HoverState<TextAnnotation>;
+import { ViewportState, UserSelectActionExpression, AnnotatorState, SelectionState, HoverState } from '@annotorious/core';
+import { TextAnnotation } from '../model';
+import { TextAnnotationStore } from './TextAnnotationStore';
+export interface TextAnnotatorState<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends AnnotatorState<I, E> {
+    store: TextAnnotationStore<I>;
+    selection: SelectionState<I, E>;
+    hover: HoverState<I>;
     viewport: ViewportState;
-};
-export declare const createTextAnnotatorState: (container: HTMLElement, defaultPointerAction?: PointerSelectAction | ((annotation: TextAnnotation) => PointerSelectAction)) => TextAnnotatorState;
+}
+export declare const createTextAnnotatorState: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(container: HTMLElement, defaultUserSelectAction?: UserSelectActionExpression<E>) => TextAnnotatorState<I, E>;

package/dist/src/state/index.d.ts

@@ -1,3 +1,2 @@
-export * from './reviveTarget';
 export * from './TextAnnotationStore';
 export * from './TextAnnotatorState';

package/dist/src/state/spatialTree.d.ts

@@ -1,6 +1,7 @@
-import type { Store } from '@annotorious/core';
-import type { TextAnnotation, TextAnnotationTarget } from '../model';
-export interface IndexedHighlightRect {
+import { Store } from '@annotorious/core';
+import { TextAnnotation, TextAnnotationTarget } from '../model';
+import { AnnotationRects } from './TextAnnotationStore';
+interface IndexedHighlightRect {
     minX: number;
     minY: number;
     maxX: number;
@@ -10,13 +11,13 @@ export interface IndexedHighlightRect {
         rects: DOMRect[];
     };
 }
-export declare const createSpatialTree: (store: Store<TextAnnotation>, container: HTMLElement) => {
+export declare const createSpatialTree: <T extends TextAnnotation>(store: Store<T>, container: HTMLElement) => {
     all: () => IndexedHighlightRect[][];
     clear: () => void;
-    getAt: (x: number, y: number) => string | undefined;
-    getBoundsForAnnotation: (id: string) => DOMRect;
-    getDOMRectsForAnnotation: (id: string) => DOMRect[];
-    getIntersectingRects: (minX: number, minY: number, maxX: number, maxY: number) => IndexedHighlightRect[];
+    getAt: (x: number, y: number, all?: boolean) => string[];
+    getAnnotationBounds: (id: string) => DOMRect;
+    getAnnotationRects: (id: string) => DOMRect[];
+    getIntersecting: (minX: number, minY: number, maxX: number, maxY: number) => AnnotationRects<T>[];
     insert: (target: TextAnnotationTarget) => void;
     recalculate: () => void;
     remove: (target: TextAnnotationTarget) => void;
@@ -24,3 +25,4 @@ export declare const createSpatialTree: (store: Store<TextAnnotation>, container
     size: () => number;
     update: (target: TextAnnotationTarget) => void;
 };
+export {};

package/dist/src/utils/cancelSingleClickEvents.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calls .preventDefault() on click events in annotable areas, in order
+ * to prevent problematic default browser behavior. (Specifically: keep
+ * Chrome Android from triggering word selection on single click.)
+ */
+export declare const cancelSingleClickEvents: (container: HTMLElement) => void;

package/dist/src/utils/cloneEvents.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Events need to be manually mapped into new objects:
+ * 1. It preserves the `target` and `currentTarget` properties.
+ *    Otherwise, they will be `null` when the event is read beyond the handler.
+ * 2. Spread operator can copy only own enumerable properties, not inherited ones.
+ *    Therefore, we need to manually copy the props we're interested in.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Event/currentTarget
+ * @see https://github.com/recogito/text-annotator-js/commit/65d13f3108c429311cf8c2523f6babbbc946013d#r144041390
+ */
+export declare const clonePointerEvent: (event: PointerEvent) => PointerEvent;
+export declare const cloneKeyboardEvent: (event: KeyboardEvent) => KeyboardEvent;

package/dist/src/utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare const debounce: <T extends (...args: any[]) => void>(func: T, delay?: number) => T;

package/dist/src/utils/device.d.ts

@@ -0,0 +1 @@
+export declare const isMac: boolean;

package/dist/src/utils/getQuoteContext.d.ts

@@ -0,0 +1,4 @@
+export declare const getQuoteContext: (range: Range, container: HTMLElement, length?: number, offsetReferenceSelector?: string) => {
+    prefix: string;
+    suffix: string;
+};

package/dist/src/utils/index.d.ts

@@ -1,3 +1,16 @@
-export * from './getClientRectsPonyfill';
+export * from './cancelSingleClickEvents';
+export * from './cloneEvents';
+export * from './device';
+export * from './programmaticallyFocusable';
+export * from './debounce';
+export * from './getQuoteContext';
+export * from './isNotAnnotatable';
+export * from './isRevived';
+export * from './isWhitespaceOrEmpty';
 export * from './mergeClientRects';
-export * from './trimRange';
+export * from './rangeToSelector';
+export * from './reviveAnnotation';
+export * from './reviveSelector';
+export * from './reviveTarget';
+export * from './splitAnnotatableRanges';
+export * from './trimRangeToContainer';

package/dist/src/utils/isNotAnnotatable.d.ts

@@ -0,0 +1,4 @@
+export declare const NOT_ANNOTATABLE_CLASS = "not-annotatable";
+export declare const NOT_ANNOTATABLE_SELECTOR = ".not-annotatable";
+export declare const isNotAnnotatable: (node: Node) => boolean;
+export declare const isRangeAnnotatable: (range: Range) => boolean;

package/dist/src/utils/isRevived.d.ts

@@ -0,0 +1,2 @@
+import { TextSelector } from '../model';
+export declare const isRevived: (selector: TextSelector[]) => boolean;

package/dist/src/utils/isWhitespaceOrEmpty.d.ts

@@ -0,0 +1,2 @@
+export declare const whitespaceOrEmptyRegex: RegExp;
+export declare const isWhitespaceOrEmpty: (range: Range) => boolean;

package/dist/src/utils/programmaticallyFocusable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Makes an element programmatically focusable by adding a `tabindex="-1"` attribute.
+ * Or does nothing if the element is already focusable 🤷🏻
+ * It's required to process keyboard events on an element that is not natively focusable.
+ */
+export declare const programmaticallyFocusable: (container: HTMLElement) => void;

package/dist/src/utils/rangeToSelector.d.ts

@@ -0,0 +1,2 @@
+import { TextSelector } from '../model';
+export declare const rangeToSelector: (range: Range, container: HTMLElement, offsetReferenceSelector?: string) => TextSelector;

package/dist/src/utils/reviveAnnotation.d.ts

@@ -0,0 +1,2 @@
+import { TextAnnotation } from '../model';
+export declare const reviveAnnotation: <T extends TextAnnotation>(annotation: T, container: HTMLElement) => T;

package/dist/src/utils/reviveSelector.d.ts

@@ -0,0 +1,11 @@
+import { TextSelector } from '../model';
+/**
+ * Creates a new selector object with the revived DOM range from the given text annotation position
+ * Only the annotatable elements are processed and counted towards the range
+ *
+ * @param selector annotation selector with start and end positions
+ * @param container the HTML container of the annotated content
+ *
+ * @returns the revived selector
+ */
+export declare const reviveSelector: <T extends TextSelector>(selector: T, container: HTMLElement) => T;

package/dist/src/utils/reviveTarget.d.ts

@@ -0,0 +1,2 @@
+import { TextAnnotationTarget } from '../model';
+export declare const reviveTarget: <T extends TextAnnotationTarget = TextAnnotationTarget>(target: T, container: HTMLElement) => T;

package/dist/src/utils/splitAnnotatableRanges.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Splits a DOM Range into one or more ranges that span annotatable content only.
+ */
+export declare const splitAnnotatableRanges: (range: Range) => Range[];
+export declare const getRangeAnnotatableContents: (range: Range) => DocumentFragment;

package/dist/src/utils/trimRangeToContainer.d.ts

@@ -0,0 +1 @@
+export declare const trimRangeToContainer: (range: Range, container: HTMLElement) => Range;

package/dist/test/model/w3c/W3CTextFormatAdapter.test.d.ts

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

package/dist/test/model/w3c/fixtures.d.ts

@@ -0,0 +1,3 @@
+import { W3CTextAnnotation } from '../../../src';
+export declare const textAnnotation: W3CTextAnnotation;
+export declare const incompleteTextAnnotation: W3CTextAnnotation;

package/dist/text-annotator.css

@@ -1 +1 @@
-html,body{overscroll-behavior-y:none}.r6o-annotatable,.r6o-annotatable *{position:relative}.r6o-annotatable.hovered{cursor:pointer}.r6o-highlight-layer{height:100vh;left:0;position:fixed;top:0;pointer-events:none;width:100vw}*::selection,::selection{background:rgba(0,128,255,.18)}::-moz-selection{background:rgba(0,128,255,.18)}
+.r6o-canvas-highlight-layer{position:fixed;top:0;bottom:0;left:0;width:100vw;height:100vh;pointer-events:none}.r6o-canvas-highlight-layer.bg{mix-blend-mode:multiply;z-index:1}.r6o-annotatable .r6o-span-highlight-layer{position:absolute;top:0;left:0;width:100%;height:100%;mix-blend-mode:multiply;pointer-events:none;z-index:1}.r6o-annotatable .r6o-span-highlight-layer.hidden{display:none}.r6o-annotatable .r6o-span-highlight-layer .r6o-annotation{position:absolute;display:block;border-style:solid;border-width:0;box-sizing:content-box}.r6o-presence-layer{left:0;position:fixed;top:0;bottom:0;width:100vw;pointer-events:none}html,body{overscroll-behavior-y:none}.r6o-annotatable{position:relative;-webkit-tap-highlight-color:transparent}.r6o-annotatable.no-focus-outline{outline:none}.hovered *{cursor:pointer}*::selection,::selection{background:#0080ff2e}::-moz-selection{background:#0080ff2e}