@recogito/text-annotator 4.0.0-beta → 4.0.2-beta

package/dist/index.d.ts

@@ -1,409 +1,12 @@
-import { Annotation } from '@annotorious/core';
-import { AnnotationBody } from '@annotorious/core';
-import { AnnotationState } from '@annotorious/core';
-import { AnnotationTarget } from '@annotorious/core';
-import { Annotator } from '@annotorious/core';
-import { AnnotatorState } from '@annotorious/core';
-import { Color } from '@annotorious/core';
-import { createBody } from '@annotorious/core';
-import { DrawingStyle } from '@annotorious/core';
-import { Filter } from '@annotorious/core';
-import { FormatAdapter } from '@annotorious/core';
-import { HoverState } from '@annotorious/core';
-import { Lifecycle } from '@annotorious/core';
-import { Origin } from '@annotorious/core';
-import { ParseResult } from '@annotorious/core';
-import { Selection as Selection_2 } from '@annotorious/core';
-import { SelectionState } from '@annotorious/core';
-import { Store } from '@annotorious/core';
-import { StoreChangeEvent } from '@annotorious/core';
-import { StoreObserver } from '@annotorious/core';
-import { Unsubscribe } from 'nanoevents';
-import { User } from '@annotorious/core';
-import { UserSelectAction } from '@annotorious/core';
-import { UserSelectActionExpression } from '@annotorious/core';
-import { ViewportState } from '@annotorious/core';
-import { W3CAnnotation } from '@annotorious/core';
-import { W3CAnnotationBody } from '@annotorious/core';
-import { W3CAnnotationTarget } from '@annotorious/core';
-
-export declare type AnnotatingMode = 'CREATE_NEW' | 'ADD_TO_CURRENT' | 'REPLACE_CURRENT';
-
-export { Annotation }
-
-export { AnnotationBody }
-
-export declare interface AnnotationRects<T extends TextAnnotation = TextAnnotation> {
-    annotation: T;
-    rects: Rect[];
-}
-
-export { AnnotationTarget }
-
-export { Annotator }
-
-export { AnnotatorState }
-
-/**
- * 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;
-
-export declare const cloneKeyboardEvent: (event: KeyboardEvent) => KeyboardEvent;
-
-/**
- * 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 { Color }
-
-export declare const computeStyle: (highlight: Highlight_2, style?: HighlightStyleExpression, z?: number) => HighlightStyle;
-
-export declare const computeZIndex: (rect: Rect, all: Highlight_2[]) => number;
-
-export { createBody }
-
-export declare const createRenderer: <T extends TextAnnotatorState = TextAnnotatorState>(painter: Painter, container: HTMLElement, state: T, viewport: ViewportState) => Renderer;
-
-export declare const createSelectionHandler: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, lifecycle: Lifecycle<TextAnnotation, unknown>, options: TextAnnotatorOptions<TextAnnotation, unknown>) => {
-    destroy: () => void;
-    setFilter: (filter?: Filter) => Filter;
-    setUser: (user?: User) => User;
-    setAnnotatingEnabled: (enabled: boolean) => void;
-    setAnnotatingMode: (mode?: AnnotatingMode) => AnnotatingMode;
-};
-
-export declare const createTextAnnotator: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(container: HTMLElement, options?: TextAnnotatorOptions<I, E>) => TextAnnotator<I, E>;
-
-export declare const createTextAnnotatorState: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(container: HTMLElement, opts: TextAnnotatorOptions<I, E>) => TextAnnotatorState<I, E>;
-
-export declare const debounce: <T extends (...args: any[]) => void>(func: T, delay?: number) => T;
-
-export declare const DEFAULT_SELECTED_STYLE: HighlightStyle;
-
-export declare const DEFAULT_STYLE: HighlightStyle;
-
-export declare type DismissOnNotAnnotatableExpression = 'NEVER' | 'ALWAYS' | ((event: Event, container: HTMLElement) => boolean);
-
-export declare const fillDefaults: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(opts: TextAnnotatorOptions<I, E>, defaults: TextAnnotatorOptions<I, E>) => TextAnnotatorOptions<I, E>;
-
-export { Filter }
-
-export { FormatAdapter }
-
-export declare const getBackgroundColor: (style?: HighlightStyle) => string;
-
-export declare const getHighlightClientRects: (range: Range) => DOMRect[];
-
-export declare const getQuoteContext: (range: Range, container: HTMLElement, length?: number, offsetReferenceSelector?: string) => {
-    prefix: string;
-    suffix: string;
-};
-
-export declare const getRangeAnnotatableContents: (range: Range) => DocumentFragment;
-
-export declare const getViewportBounds: (container: HTMLElement) => ViewportBounds;
-
-declare interface Highlight_2 extends AnnotationRects<TextAnnotation> {
-    state: AnnotationState;
-}
-export { Highlight_2 as Highlight }
-
-export declare interface HighlightStyle extends Pick<DrawingStyle, 'fill' | 'fillOpacity'> {
-    underlineStyle?: string;
-    underlineColor?: Color;
-    underlineOffset?: number;
-    underlineThickness?: number;
-}
-
-export declare type HighlightStyleExpression = HighlightStyle | (<I extends TextAnnotation = TextAnnotation>(annotation: I, state: AnnotationState, zIndex?: number) => HighlightStyle | undefined);
-
-export { HoverState }
-
-export declare const isMac: boolean;
-
-export declare const isNodeWhitespaceOrEmpty: (node: Node) => boolean;
-
-export declare const isNotAnnotatable: (container: Node, node: Node) => boolean;
-
-export declare const isRangeAnnotatable: (container: Node, range: Range) => boolean;
-
-export declare const isRangeWhitespaceOrEmpty: (range: Range) => boolean;
-
-export declare const isRevived: (selector: TextSelector[]) => boolean;
-
-export declare const mergeClientRects: (rects: DOMRect[], hTolerance?: number, vTolerance?: number) => DOMRect[];
-
-export declare const mergeRanges: (ranges: Range[]) => Range[];
-
-export declare const NOT_ANNOTATABLE_CLASS = "not-annotatable";
-
-export declare const NOT_ANNOTATABLE_SELECTOR = ".not-annotatable";
-
-export { Origin }
-
-/**
- * A utility interface. Instead of implementing a Renderer from scratch,
- * implementers can simply implement a painter, and wrap it in the
- * BaseRenderer, which will handle common concerns.
- */
-export declare interface Painter {
-    destroy(): void;
-    redraw(highlights: Highlight_2[], bounds: ViewportBounds, style?: HighlightStyleExpression, styleOverrides?: Map<string, HighlightStyleExpression>, force?: boolean): void;
-    setVisible(visible: boolean): void;
-}
-
-export { ParseResult }
-
-export declare const parseW3CTextAnnotation: <I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation>(annotation: E) => ParseResult<I>;
-
-/**
- * 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;
-
-export declare const rangeToSelector: (range: Range, container: HTMLElement, offsetReferenceSelector?: string) => TextSelector;
-
-export declare interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-
-/**
- * The renderer runtime interface.
- */
-export declare interface Renderer {
-    destroy(): void;
-    on: <E extends keyof RendererEvents>(event: E, callback: RendererEvents[E]) => Unsubscribe;
-    redraw(force?: boolean): void;
-    setStyle(style?: HighlightStyleExpression, id?: string): void;
-    setFilter(filter?: Filter): void;
-    setVisible(visible: boolean): void;
-}
-
-export declare interface RendererEvents {
-    onRedraw(): void;
-}
-
-export declare type RendererFactory = (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => Renderer;
-
-export declare type RendererType = 'SPANS' | 'CSS_HIGHLIGHTS';
-
-export declare const reviveAnnotation: <T extends TextAnnotation>(annotation: T, container: HTMLElement) => T;
-
-/**
- * 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;
-
-export declare const reviveTarget: <T extends TextAnnotationTarget = TextAnnotationTarget>(target: T, container: HTMLElement) => T;
-
-export declare const scrollIntoView: <I extends TextAnnotation = TextAnnotation>(container: HTMLElement, store: TextAnnotationStore<I>) => <E extends Element = Element>(annotationOrId: string | I, scrollParentOrId?: string | E) => boolean;
-
-export { Selection_2 as Selection }
-
-export { SelectionState }
-
-export declare const serializeW3CTextAnnotation: <I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation>(annotation: I, source: string, container?: HTMLElement) => E;
-
-declare interface SpatialTreeEvents {
-    recalculate(): void;
-}
-
-/**
- * Splits a DOM Range into one or more ranges that span annotatable content only.
- */
-export declare const splitAnnotatableRanges: (container: Node, range: Range) => Range[];
-
-export { Store }
-
-export { StoreChangeEvent }
-
-export { StoreObserver }
-
-export declare interface TextAnnotation extends Annotation {
-    target: TextAnnotationTarget;
-}
-
-export declare interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotation'> {
-    addAnnotation(annotation: T, origin?: Origin): boolean;
-    bulkAddAnnotations(annotations: T[], replace: boolean, origin?: Origin): T[];
-    bulkUpsertAnnotations(annotations: T[], origin?: Origin): T[];
-    getAnnotationRects(id: string): DOMRect[];
-    getAnnotationBounds(id: string): DOMRect | undefined;
-    getAnnotationRects(id: string): DOMRect[];
-    getAt(x: number, y: number, all: true, filter?: Filter): T[] | undefined;
-    getAt(x: number, y: number, all: false, filter?: Filter): T | undefined;
-    getAt(x: number, y: number, all?: boolean, filter?: Filter): T | T[] | undefined;
-    getIntersecting(minX: number, minY: number, maxX: number, maxY: number): AnnotationRects<T>[];
-    recalculatePositions(): void;
-    onRecalculatePositions(callback: SpatialTreeEvents['recalculate']): Unsubscribe;
-}
-
-export declare interface TextAnnotationTarget extends AnnotationTarget {
-    selector: TextSelector[];
-}
-
-export declare interface TextAnnotator<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Annotator<I, E> {
-    element: HTMLElement;
-    renderer: Renderer;
-    setStyle(style?: HighlightStyleExpression, id?: string): void;
-    scrollIntoView(annotationOrId: I | string, scrollParentOrId?: string | Element): boolean;
-    setAnnotatingEnabled(enabled?: boolean): void;
-    setAnnotatingMode(mode?: AnnotatingMode): void;
-    state: TextAnnotatorState<I, E>;
-}
-
-export declare interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> {
-    adapter?: FormatAdapter<I, E> | null;
-    allowModifierSelect?: boolean;
-    annotatingEnabled?: boolean;
-    /**
-     * Determines whether an active selection should be dismissed
-     * when a user ends their interaction (click, selection)
-     * on a non-annotatable element.
-     * - NEVER - don't dismiss the selection, ignore the action.
-     * - ALWAYS - dismiss the selection.
-     * - function - a custom matcher that takes an event and container as arguments.
-     *              Returns `true` if the selection should be dismissed.
-     *
-     * @defaut NEVER
-     */
-    dismissOnNotAnnotatable?: DismissOnNotAnnotatableExpression;
-    mergeHighlights?: {
-        horizontalTolerance?: number;
-        verticalTolerance?: number;
-    };
-    offsetReferenceSelector?: string;
-    renderer?: RendererType | RendererFactory;
-    selectionMode?: 'shortest' | 'all';
-    style?: HighlightStyleExpression;
-    user?: User;
-    userSelectAction?: UserSelectActionExpression<E>;
-}
-
-export declare 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 interface TextSelector {
-    id?: string;
-    quote: string;
-    start: number;
-    end: number;
-    range: Range;
-    offsetReference?: HTMLElement;
-}
-
-export declare const toDomRectList: (rects: DOMRect[]) => DOMRectList;
-
-/**
- * Offsets the given rect relative to the offset parent.
- */
-export declare const toParentBounds: (rect: DOMRect, offset: DOMRect) => DOMRect;
-
-/**
- * Inverse: translates the given relative rect back into viewport bounds.
- */
-export declare const toViewportBounds: (rect: DOMRect, offset: DOMRect) => DOMRect;
-
-export declare const trackViewport: (viewport: ViewportState) => (annotations: TextAnnotation[]) => void;
-
-export declare const trimRangeToContainer: (range: Range, container: HTMLElement) => Range;
-
-export { User }
-
-export { UserSelectAction }
-
-export { UserSelectActionExpression }
-
-export declare interface ViewportBounds {
-    top: number;
-    left: number;
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-
-export { ViewportState }
-
-export { W3CAnnotation }
-
-export { W3CAnnotationBody }
-
-export declare type W3CAnnotationStylesheet = string | {
-    type: 'CssStylesheet';
-    value: string;
-};
-
-export { W3CAnnotationTarget }
-
-export declare interface W3CTextAnnotation extends W3CAnnotation {
-    target: W3CTextAnnotationTarget | W3CTextAnnotationTarget[];
-    stylesheet?: W3CAnnotationStylesheet;
-}
-
-export declare interface W3CTextAnnotationTarget extends W3CAnnotationTarget {
-    selector: W3CTextSelector | W3CTextSelector[];
-    styleClass?: string;
-    scope?: string;
-}
-
-/**
- * @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: <I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation>(source: string, container?: HTMLElement) => W3CTextFormatAdapter<I, E>;
-
-export declare type W3CTextFormatAdapter<I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation> = FormatAdapter<I, E>;
-
-/**
- * Matches the `Text Position Selector` spec
- * @see https://www.w3.org/TR/annotation-model/#text-position-selector
- */
-export declare interface W3CTextPositionSelector {
-    type: 'TextPositionSelector';
-    start: number;
-    end: number;
-}
-
-/**
- * Matches the `Text Quote Selector` spec
- * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
- */
-export declare interface W3CTextQuoteSelector {
-    type: 'TextQuoteSelector';
-    exact: string;
-    prefix?: string;
-    suffix?: string;
-}
-
-export declare type W3CTextSelector = W3CTextQuoteSelector | W3CTextPositionSelector;
-
-export declare const whitespaceOrEmptyRegex: RegExp;
-
-export { }
+export * from './model';
+export * from './rendering';
+export * from './state';
+export * from './utils/annotation';
+export * from './utils/dom';
+export * from './utils/events';
+export * from './utils/highlight';
+export * from './selection-handler';
+export * from './text-annotator';
+export * from './text-annotator-options';
+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/model/core/text-annotation.d.ts

@@ -1,4 +1,4 @@
-import { Annotation, AnnotationTarget } from '@annotorious/core';
+import type { Annotation, AnnotationTarget } from '@annotorious/core';
 export interface TextAnnotation extends Annotation {
     target: TextAnnotationTarget;
 }

package/dist/model/w3c/w3c-text-annotation.d.ts

@@ -1,4 +1,4 @@
-import { W3CAnnotation, W3CAnnotationTarget } from '@annotorious/core';
+import type { W3CAnnotation, W3CAnnotationTarget } from '@annotorious/core';
 export interface W3CTextAnnotation extends W3CAnnotation {
     target: W3CTextAnnotationTarget | W3CTextAnnotationTarget[];
     stylesheet?: W3CAnnotationStylesheet;

package/dist/model/w3c/w3c-text-format-adapter.d.ts

@@ -1,6 +1,6 @@
-import { TextAnnotation } from '../core';
-import { W3CTextAnnotation } from '.';
-import { FormatAdapter, ParseResult } from '@annotorious/core';
+import type { TextAnnotation } from '../core';
+import type { W3CTextAnnotation } from './';
+import { type FormatAdapter, type ParseResult } from '@annotorious/core';
 export type W3CTextFormatAdapter<I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation> = FormatAdapter<I, E>;
 /**
  * @param source - the IRI of the annotated content

package/dist/rendering/base-renderer.d.ts

@@ -1,8 +1,8 @@
-import { Unsubscribe } from 'nanoevents';
-import { Filter, ViewportState } from '@annotorious/core';
-import { TextAnnotation } from '../model';
-import { TextAnnotatorState } from '../state';
-import { Highlight, HighlightStyleExpression, ViewportBounds } from '.';
+import { type Unsubscribe } from 'nanoevents';
+import { type Filter, type ViewportState } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
+import type { TextAnnotatorState } from '../state';
+import { type Highlight, type HighlightStyleExpression, type ViewportBounds } from './';
 /**
  * The renderer runtime interface.
  */
@@ -11,13 +11,13 @@ export interface Renderer {
     on: <E extends keyof RendererEvents>(event: E, callback: RendererEvents[E]) => Unsubscribe;
     redraw(force?: boolean): void;
     setStyle(style?: HighlightStyleExpression, id?: string): void;
-    setFilter(filter?: Filter): void;
+    setFilter(filter?: Filter<any>): void;
     setVisible(visible: boolean): void;
 }
 export interface RendererEvents {
     onRedraw(): void;
 }
-export type RendererFactory = (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => Renderer;
+export type RendererFactory<T extends TextAnnotation> = (container: HTMLElement, state: TextAnnotatorState<T, any>, viewport: ViewportState) => Renderer;
 /**
  * A utility interface. Instead of implementing a Renderer from scratch,
  * implementers can simply implement a painter, and wrap it in the
@@ -28,4 +28,4 @@ export interface Painter {
     redraw(highlights: Highlight[], bounds: ViewportBounds, style?: HighlightStyleExpression, styleOverrides?: Map<string, HighlightStyleExpression>, force?: boolean): void;
     setVisible(visible: boolean): void;
 }
-export declare const createRenderer: <T extends TextAnnotatorState = TextAnnotatorState>(painter: Painter, container: HTMLElement, state: T, viewport: ViewportState) => Renderer;
+export declare const createRenderer: <T extends TextAnnotatorState = TextAnnotatorState<TextAnnotation, any>>(painter: Painter, container: HTMLElement, state: T, viewport: ViewportState) => Renderer;

package/dist/rendering/highlight-style.d.ts

@@ -1,6 +1,6 @@
-import { AnnotationState, Color, DrawingStyle } from '@annotorious/core';
-import { TextAnnotation } from '../model';
-import { Highlight } from '.';
+import type { AnnotationState, Color, DrawingStyle } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
+import type { Highlight } from './';
 export interface HighlightStyle extends Pick<DrawingStyle, 'fill' | 'fillOpacity'> {
     underlineStyle?: string;
     underlineColor?: Color;

package/dist/rendering/highlight.d.ts

@@ -1,6 +1,6 @@
-import { AnnotationState } from '@annotorious/core';
-import { TextAnnotation } from '../model';
-import { AnnotationRects } from '../state';
+import type { AnnotationState } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
+import type { AnnotationRects } from '../state';
 export interface Highlight extends AnnotationRects<TextAnnotation> {
     state: AnnotationState;
 }

package/dist/rendering/index.d.ts

@@ -1,4 +1,5 @@
 export * from './base-renderer';
 export * from './highlight';
 export * from './highlight-style';
+export * from './renderer-spans';
 export * from './viewport';

package/dist/rendering/renderer-css-highlight/css-highlight-renderer.d.ts

@@ -1,6 +1,7 @@
-import { Painter, RendererFactory } from '..';
+import type { TextAnnotation } from '../../model';
+import { type Painter, type RendererFactory } from '../';
 /**
  * EXPERIMENTAL!
  */
 export declare const createCSSHighlightPainter: () => Painter;
-export declare const createCSSHighlightRenderer: RendererFactory;
+export declare const createCSSHighlightRenderer: RendererFactory<TextAnnotation>;

package/dist/rendering/renderer-spans/spans-renderer.d.ts

@@ -1,2 +1,4 @@
-import { RendererFactory } from '..';
-export declare const createSpansRenderer: RendererFactory;
+import type { TextAnnotation } from '../../model';
+import { type RendererFactory } from '../';
+import './spans-renderer.css';
+export declare const createSpansRenderer: RendererFactory<TextAnnotation>;

package/dist/rendering/viewport.d.ts

@@ -1,5 +1,5 @@
-import { ViewportState } from '@annotorious/core';
-import { TextAnnotation } from '../model';
+import type { ViewportState } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
 export interface ViewportBounds {
     top: number;
     left: number;

package/dist/selection-handler.d.ts

@@ -1,11 +1,11 @@
-import { Filter, Lifecycle, User } from '@annotorious/core';
-import { TextAnnotatorState } from './state';
-import { TextAnnotation } from './model';
-import { AnnotatingMode } from './text-annotator';
-import { TextAnnotatorOptions } from './text-annotator-options';
-export declare const createSelectionHandler: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, lifecycle: Lifecycle<TextAnnotation, unknown>, options: TextAnnotatorOptions<TextAnnotation, unknown>) => {
+import type { Filter, Lifecycle, User } from '@annotorious/core';
+import type { TextAnnotatorState } from './state';
+import type { TextAnnotation } from './model';
+import type { AnnotatingMode } from './text-annotator';
+import type { TextAnnotatorOptions } from './text-annotator-options';
+export declare const createSelectionHandler: <T extends TextAnnotation>(container: HTMLElement, state: TextAnnotatorState<TextAnnotation, any>, lifecycle: Lifecycle<TextAnnotation, any>, options: TextAnnotatorOptions<TextAnnotation, any>) => {
     destroy: () => void;
-    setFilter: (filter?: Filter) => Filter;
+    setFilter: (filter?: Filter<any>) => Filter<any>;
     setUser: (user?: User) => User;
     setAnnotatingEnabled: (enabled: boolean) => void;
     setAnnotatingMode: (mode?: AnnotatingMode) => AnnotatingMode;

package/dist/state/spatial-tree.d.ts

@@ -1,7 +1,7 @@
-import { Store } from '@annotorious/core';
-import { Unsubscribe } from 'nanoevents';
-import { TextAnnotation, TextAnnotationTarget } from '../model';
-import { AnnotationRects } from './text-annotation-store';
+import type { Store } from '@annotorious/core';
+import { type Unsubscribe } from 'nanoevents';
+import type { TextAnnotation, TextAnnotationTarget } from '../model';
+import type { AnnotationRects } from '../state/text-annotation-store';
 interface IndexedHighlightRect {
     minX: number;
     minY: number;
@@ -19,7 +19,7 @@ export declare const createSpatialTree: <T extends TextAnnotation>(store: Store<
     all: () => IndexedHighlightRect[][];
     clear: () => void;
     getAt: (x: number, y: number, all?: boolean) => string[];
-    getAnnotationBounds: (id: string) => DOMRect;
+    getAnnotationBounds: (id: string) => DOMRect | undefined;
     getAnnotationRects: (id: string) => DOMRect[];
     getIntersecting: (minX: number, minY: number, maxX: number, maxY: number) => AnnotationRects<T>[];
     insert: (target: TextAnnotationTarget) => void;

package/dist/state/text-annotation-store.d.ts

@@ -1,8 +1,8 @@
-import { Unsubscribe } from 'nanoevents';
-import { Filter, Origin, Store } from '@annotorious/core';
-import { TextAnnotation } from '../model';
-import { SpatialTreeEvents } from './spatial-tree';
-export interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotation'> {
+import type { Unsubscribe } from 'nanoevents';
+import type { Filter, Origin, Store } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
+import type { SpatialTreeEvents } from '../state/spatial-tree';
+export interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotations' | 'bulkUpsertAnnotations'> {
     addAnnotation(annotation: T, origin?: Origin): boolean;
     bulkAddAnnotations(annotations: T[], replace: boolean, origin?: Origin): T[];
     bulkUpsertAnnotations(annotations: T[], origin?: Origin): T[];

package/dist/state/text-annotator-state.d.ts

@@ -1,8 +1,9 @@
-import { ViewportState, AnnotatorState, SelectionState, HoverState } from '@annotorious/core';
-import { TextAnnotation } from '../model';
-import { TextAnnotationStore } from './text-annotation-store';
-import { TextAnnotatorOptions } from '../text-annotator-options';
-export interface TextAnnotatorState<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends AnnotatorState<I, E> {
+import type { ViewportState } from '@annotorious/core';
+import type { AnnotatorState, SelectionState, HoverState } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
+import type { TextAnnotationStore } from '../state/text-annotation-store';
+import type { TextAnnotatorOptions } from '../text-annotator-options';
+export interface TextAnnotatorState<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Omit<AnnotatorState<I, E>, 'store'> {
     store: TextAnnotationStore<I>;
     selection: SelectionState<I, E>;
     hover: HoverState<I>;

package/dist/text-annotator-options.d.ts

@@ -1,8 +1,8 @@
-import { FormatAdapter, UserSelectActionExpression, User } from '@annotorious/core';
-import { HighlightStyleExpression, RendererFactory } from './rendering';
-import { TextAnnotation } from './model';
+import type { FormatAdapter, UserSelectActionExpression, User } from '@annotorious/core';
+import type { HighlightStyleExpression, RendererFactory } from './rendering';
+import type { TextAnnotation } from './model';
 export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> {
-    adapter?: FormatAdapter<I, E> | null;
+    adapter?: FormatAdapter<I, E>;
     allowModifierSelect?: boolean;
     annotatingEnabled?: boolean;
     /**
@@ -22,7 +22,7 @@ export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation,
         verticalTolerance?: number;
     };
     offsetReferenceSelector?: string;
-    renderer?: RendererType | RendererFactory;
+    renderer?: RendererType | RendererFactory<I>;
     selectionMode?: 'shortest' | 'all';
     style?: HighlightStyleExpression;
     user?: User;

package/dist/text-annotator.css

@@ -1 +1 @@
-.r6o-annotatable .r6o-span-highlight-layer{position:absolute;top:0;left:0;width:100%;height:100%;mix-blend-mode:multiply;pointer-events:none;overflow:hidden;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}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}
+.r6o-annotatable .r6o-span-highlight-layer{position:absolute;top:0;left:0;width:100%;height:100%;mix-blend-mode:multiply;pointer-events:none;overflow:hidden;user-select:none;-webkit-user-select: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}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}