@embedpdf/plugin-annotation 2.6.2 → 2.8.0

package/dist/shared-react/components/annotations/polyline.d.ts

@@ -1,5 +1,5 @@
-import { MouseEvent, TouchEvent } from '../../../react/adapter.ts';
-import { Rect, Position, LineEndings } from '@embedpdf/models';
+import { MouseEvent } from '../../../react/adapter.ts';
+import { Rect, Position, LineEndings, PdfAnnotationBorderStyle } from '@embedpdf/models';
 interface PolylineProps {
     rect: Rect;
     vertices: Position[];
@@ -7,11 +7,17 @@ interface PolylineProps {
     strokeColor?: string;
     opacity?: number;
     strokeWidth: number;
+    /** Stroke style */
+    strokeStyle?: PdfAnnotationBorderStyle;
+    /** Stroke dash array */
+    strokeDashArray?: number[];
     scale: number;
     isSelected: boolean;
-    onClick?: (e: MouseEvent<SVGElement> | TouchEvent<SVGElement>) => void;
+    onClick?: (e: MouseEvent<SVGElement>) => void;
     /** Optional start & end endings */
     lineEndings?: LineEndings;
+    /** When true, AP canvas provides the visual; only render hit area */
+    appearanceActive?: boolean;
 }
-export declare function Polyline({ rect, vertices, color, strokeColor, opacity, strokeWidth, scale, isSelected, onClick, lineEndings, }: PolylineProps): JSX.Element;
+export declare function Polyline({ rect, vertices, color, strokeColor, opacity, strokeWidth, strokeStyle, strokeDashArray, scale, isSelected, onClick, lineEndings, appearanceActive, }: PolylineProps): JSX.Element;
 export {};

package/dist/shared-react/components/annotations/square.d.ts

@@ -1,9 +1,9 @@
-import { MouseEvent, TouchEvent } from '../../../react/adapter.ts';
+import { MouseEvent } from '../../../react/adapter.ts';
 import { PdfAnnotationBorderStyle, Rect } from '@embedpdf/models';
 interface SquareProps {
     /** Whether the annotation is selected */
     isSelected: boolean;
-    /** Fill colour – defaults to PDFium’s black if omitted */
+    /** Fill colour – defaults to PDFium's black if omitted */
     color?: string;
     /** Stroke colour – defaults to same as fill when omitted */
     strokeColor?: string;
@@ -20,10 +20,12 @@ interface SquareProps {
     /** Current page zoom factor */
     scale: number;
     /** Click handler (used for selection) */
-    onClick?: (e: MouseEvent<SVGElement> | TouchEvent<SVGElement>) => void;
+    onClick?: (e: MouseEvent<SVGElement>) => void;
+    /** When true, AP canvas provides the visual; only render hit area */
+    appearanceActive?: boolean;
 }
 /**
  * Renders a PDF Square annotation (rectangle) as SVG.
  */
-export declare function Square({ isSelected, color, strokeColor, opacity, strokeWidth, strokeStyle, strokeDashArray, rect, scale, onClick, }: SquareProps): JSX.Element;
+export declare function Square({ isSelected, color, strokeColor, opacity, strokeWidth, strokeStyle, strokeDashArray, rect, scale, onClick, appearanceActive, }: SquareProps): JSX.Element;
 export {};

package/dist/shared-react/components/annotations/stamp.d.ts

@@ -1,4 +1,4 @@
-import { MouseEvent, TouchEvent } from '../../../react/adapter.ts';
+import { MouseEvent } from '../../../react/adapter.ts';
 import { PdfStampAnnoObject } from '@embedpdf/models';
 import { TrackedAnnotation } from '../../../lib/index.ts';
 interface StampProps {
@@ -7,7 +7,7 @@ interface StampProps {
     documentId: string;
     pageIndex: number;
     scale: number;
-    onClick: (e: MouseEvent<HTMLDivElement> | TouchEvent<HTMLDivElement>) => void;
+    onClick: (e: MouseEvent<HTMLDivElement>) => void;
 }
 export declare function Stamp({ isSelected, annotation, documentId, pageIndex, scale, onClick, }: StampProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared-react/components/annotations/text.d.ts

@@ -0,0 +1,14 @@
+import { MouseEvent } from '../../../react/adapter.ts';
+interface TextProps {
+    isSelected: boolean;
+    color?: string;
+    opacity?: number;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    appearanceActive?: boolean;
+}
+/**
+ * Renders a fallback sticky-note icon for PDF Text annotations when no
+ * appearance stream image is available.
+ */
+export declare function Text({ isSelected, color, opacity, onClick, appearanceActive, }: TextProps): JSX.Element;
+export {};

package/dist/shared-react/components/annotations.d.ts

@@ -16,7 +16,6 @@ interface AnnotationsProps {
     selectionOutline?: SelectionOutline;
     groupSelectionOutline?: SelectionOutline;
     customAnnotationRenderer?: CustomAnnotationRenderer<PdfAnnotationObject>;
-    /** Custom renderers for specific annotation types (provided by external plugins) */
     annotationRenderers?: BoxedAnnotationRenderer[];
 }
 export declare function Annotations(annotationsProps: AnnotationsProps): import("react/jsx-runtime").JSX.Element;

package/dist/shared-react/components/appearance-image.d.ts

@@ -0,0 +1,12 @@
+import { AnnotationAppearanceImage } from '@embedpdf/models';
+import { CSSProperties } from '../../react/adapter.ts';
+interface AppearanceImageProps {
+    appearance: AnnotationAppearanceImage<Blob>;
+    style?: CSSProperties;
+}
+/**
+ * Renders a pre-rendered annotation appearance stream image as an img URL.
+ * Purely visual -- pointer events are always disabled; hit-area SVG handles interaction.
+ */
+export declare function AppearanceImage({ appearance, style }: AppearanceImageProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/shared-react/components/built-in-renderers.d.ts

@@ -0,0 +1,2 @@
+import { BoxedAnnotationRenderer } from './types';
+export declare const builtInRenderers: BoxedAnnotationRenderer[];

package/dist/shared-react/components/text-markup/highlight.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties, MouseEvent, TouchEvent } from '../../../react/adapter.ts';
+import { CSSProperties, MouseEvent } from '../../../react/adapter.ts';
 import { Rect } from '@embedpdf/models';
 type HighlightProps = {
     /** Stroke/markup color */
@@ -7,8 +7,10 @@ type HighlightProps = {
     segmentRects: Rect[];
     rect?: Rect;
     scale: number;
-    onClick?: (e: MouseEvent<HTMLDivElement> | TouchEvent<HTMLDivElement>) => void;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
     style?: CSSProperties;
+    /** When true, AP image provides the visual; only render hit area */
+    appearanceActive?: boolean;
 };
-export declare function Highlight({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, }: HighlightProps): import("react/jsx-runtime").JSX.Element;
+export declare function Highlight({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, appearanceActive, }: HighlightProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared-react/components/text-markup/squiggly.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties, MouseEvent, TouchEvent } from '../../../react/adapter.ts';
+import { CSSProperties, MouseEvent } from '../../../react/adapter.ts';
 import { Rect } from '@embedpdf/models';
 type SquigglyProps = {
     /** Stroke/markup color */
@@ -7,8 +7,10 @@ type SquigglyProps = {
     segmentRects: Rect[];
     rect?: Rect;
     scale: number;
-    onClick?: (e: MouseEvent<HTMLDivElement> | TouchEvent<HTMLDivElement>) => void;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
     style?: CSSProperties;
+    /** When true, AP image provides the visual; only render hit area */
+    appearanceActive?: boolean;
 };
-export declare function Squiggly({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, }: SquigglyProps): import("react/jsx-runtime").JSX.Element;
+export declare function Squiggly({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, appearanceActive, }: SquigglyProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared-react/components/text-markup/strikeout.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties, MouseEvent, TouchEvent } from '../../../react/adapter.ts';
+import { CSSProperties, MouseEvent } from '../../../react/adapter.ts';
 import { Rect } from '@embedpdf/models';
 type StrikeoutProps = {
     /** Stroke/markup color */
@@ -7,8 +7,10 @@ type StrikeoutProps = {
     segmentRects: Rect[];
     rect?: Rect;
     scale: number;
-    onClick?: (e: MouseEvent<HTMLDivElement> | TouchEvent<HTMLDivElement>) => void;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
     style?: CSSProperties;
+    /** When true, AP image provides the visual; only render hit area */
+    appearanceActive?: boolean;
 };
-export declare function Strikeout({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, }: StrikeoutProps): import("react/jsx-runtime").JSX.Element;
+export declare function Strikeout({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, appearanceActive, }: StrikeoutProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared-react/components/text-markup/underline.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties, MouseEvent, TouchEvent } from '../../../react/adapter.ts';
+import { CSSProperties, MouseEvent } from '../../../react/adapter.ts';
 import { Rect } from '@embedpdf/models';
 type UnderlineProps = {
     /** Stroke/markup color */
@@ -7,8 +7,10 @@ type UnderlineProps = {
     segmentRects: Rect[];
     rect?: Rect;
     scale: number;
-    onClick?: (e: MouseEvent<HTMLDivElement> | TouchEvent<HTMLDivElement>) => void;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
     style?: CSSProperties;
+    /** When true, AP image provides the visual; only render hit area */
+    appearanceActive?: boolean;
 };
-export declare function Underline({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, }: UnderlineProps): import("react/jsx-runtime").JSX.Element;
+export declare function Underline({ strokeColor, opacity, segmentRects, rect, scale, onClick, style, appearanceActive, }: UnderlineProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared-react/components/types.d.ts

@@ -1,7 +1,8 @@
 import { PdfAnnotationObject } from '@embedpdf/models';
 import { TrackedAnnotation } from '../../lib/index.ts';
 import { HandleElementProps, SelectionMenuPropsBase, SelectionMenuRenderFn } from '../../react/utils.ts';
-import { JSX, CSSProperties, MouseEvent, TouchEvent } from '../../react/adapter.ts';
+import { JSX, CSSProperties, MouseEvent } from '../../react/adapter.ts';
+import { VertexConfig } from '../types';
 export type ResizeDirection = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'none';
 export interface AnnotationSelectionContext {
     type: 'annotation';
@@ -106,15 +107,34 @@ export interface CustomAnnotationRendererProps<T extends PdfAnnotationObject> {
  * Custom renderer for an annotation
  */
 export type CustomAnnotationRenderer<T extends PdfAnnotationObject> = (props: CustomAnnotationRendererProps<T>) => JSX.Element | null;
+/**
+ * Properly typed event for annotation interactions (click, select, etc.)
+ */
+export type AnnotationInteractionEvent = MouseEvent<Element>;
 /**
  * Props for an annotation renderer entry
  */
-export interface AnnotationRendererProps<T extends PdfAnnotationObject> {
+export interface AnnotationRendererProps<T extends PdfAnnotationObject = PdfAnnotationObject> {
     annotation: TrackedAnnotation<T>;
+    currentObject: T;
     isSelected: boolean;
+    isEditing: boolean;
     scale: number;
     pageIndex: number;
-    onClick: (e: MouseEvent<Element> | TouchEvent<Element>) => void;
+    documentId: string;
+    onClick: (e: AnnotationInteractionEvent) => void;
+    /** When true, AP canvas provides the visual; component should only render hit area */
+    appearanceActive: boolean;
+}
+/**
+ * Helpers passed to selectOverride for custom selection behavior.
+ */
+export interface SelectOverrideHelpers {
+    defaultSelect: (e: AnnotationInteractionEvent, annotation: TrackedAnnotation) => void;
+    selectAnnotation: (pageIndex: number, id: string) => void;
+    clearSelection: () => void;
+    allAnnotations: TrackedAnnotation[];
+    pageIndex: number;
 }
 /**
  * Entry for a custom annotation renderer that handles specific annotation types.
@@ -128,20 +148,56 @@ export interface AnnotationRendererEntry<T extends PdfAnnotationObject = PdfAnno
     matches: (annotation: PdfAnnotationObject) => annotation is T;
     /** The component to render the annotation */
     render: (props: AnnotationRendererProps<T>) => JSX.Element;
+    /** Vertex configuration for annotations with draggable vertices (line, polyline, polygon) */
+    vertexConfig?: VertexConfig<T>;
+    /** z-index for the annotation container (default: 1, text markup uses 0) */
+    zIndex?: number;
+    /** Style applied to the annotation container (overrides default blendMode style) */
+    containerStyle?: (annotation: T) => CSSProperties;
+    /** Type-specific interaction fallbacks used when the tool doesn't define a property */
+    interactionDefaults?: {
+        isDraggable?: boolean;
+        isResizable?: boolean;
+        isRotatable?: boolean;
+        lockAspectRatio?: boolean;
+    };
+    /** Whether this annotation type uses AP rendering before editing (default: true) */
+    useAppearanceStream?: boolean;
+    /** Override resolved isDraggable (e.g., FreeText disables drag while editing) */
+    isDraggable?: (toolDraggable: boolean, context: {
+        isEditing: boolean;
+    }) => boolean;
+    /** Handle double-click on the annotation container */
+    onDoubleClick?: (annotationId: string, setEditingId: (id: string) => void) => void;
+    /** Override default selection behavior (e.g., Link IRT parent resolution) */
+    selectOverride?: (e: AnnotationInteractionEvent, annotation: TrackedAnnotation<T>, helpers: SelectOverrideHelpers) => void;
+    /** Return true to hide the selection menu for this annotation */
+    hideSelectionMenu?: (annotation: T) => boolean;
 }
-/**
- * Props passed to tryRender (everything except annotation which is passed separately)
- */
-export type BoxedRendererProps = Omit<AnnotationRendererProps<PdfAnnotationObject>, 'annotation'>;
 /**
  * Boxed renderer that encapsulates type safety internally.
- * The generic is erased - this is what the registry actually stores.
+ * The generic is erased -- this is what the registry actually stores.
  */
 export interface BoxedAnnotationRenderer {
-    /** Unique identifier for this renderer */
     id: string;
-    /** Combined match + render: returns null if doesn't match, JSX.Element if it does */
-    tryRender: (annotation: TrackedAnnotation, props: BoxedRendererProps) => JSX.Element | null;
+    matches: (annotation: PdfAnnotationObject) => boolean;
+    render: (props: AnnotationRendererProps) => JSX.Element;
+    vertexConfig?: VertexConfig<PdfAnnotationObject>;
+    zIndex?: number;
+    containerStyle?: (annotation: PdfAnnotationObject) => CSSProperties;
+    interactionDefaults?: {
+        isDraggable?: boolean;
+        isResizable?: boolean;
+        isRotatable?: boolean;
+        lockAspectRatio?: boolean;
+    };
+    useAppearanceStream?: boolean;
+    isDraggable?: (toolDraggable: boolean, context: {
+        isEditing: boolean;
+    }) => boolean;
+    onDoubleClick?: (annotationId: string, setEditingId: (id: string) => void) => void;
+    selectOverride?: (e: AnnotationInteractionEvent, annotation: TrackedAnnotation, helpers: SelectOverrideHelpers) => void;
+    hideSelectionMenu?: (annotation: PdfAnnotationObject) => boolean;
 }
 /**
  * Creates a boxed renderer from a typed entry.

package/dist/shared-vue/annotation-bounds.d.ts

@@ -0,0 +1,14 @@
+import { Rotation } from '@embedpdf/models';
+import { TrackedAnnotation } from '../lib';
+export interface ScreenBounds {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * Compute the screen-space bounding box of an annotation, correctly accounting
+ * for `noZoom` (constant pixel size regardless of zoom) and `noRotate`
+ * (visually upright regardless of page rotation) annotation flags.
+ */
+export declare function getAnnotationScreenBounds(annotation: TrackedAnnotation, scale: number, rotation: Rotation): ScreenBounds;

package/dist/svelte/components/Annotations.svelte.d.ts

@@ -9,25 +9,18 @@ interface AnnotationsProps {
     rotation: number;
     pageWidth: number;
     pageHeight: number;
-    /** Render function for selection menu (schema-driven approach) */
     selectionMenu?: AnnotationSelectionMenuRenderFn;
-    /** Snippet for custom selection menu (slot-based approach) */
     selectionMenuSnippet?: Snippet<[AnnotationSelectionMenuProps]>;
-    /** Render function for group selection menu (schema-driven approach) */
     groupSelectionMenu?: GroupSelectionMenuRenderFn;
-    /** Snippet for custom group selection menu (slot-based approach) */
     groupSelectionMenuSnippet?: Snippet<[GroupSelectionMenuProps]>;
     resizeUI?: ResizeHandleUI;
     vertexUI?: VertexHandleUI;
     rotationUI?: RotationHandleUI;
     /** @deprecated Use `selectionOutline` instead */
     selectionOutlineColor?: string;
-    /** Customize the selection outline for individual annotations */
     selectionOutline?: SelectionOutline;
-    /** Customize the selection outline for the group selection box (falls back to selectionOutline) */
     groupSelectionOutline?: SelectionOutline;
     customAnnotationRenderer?: CustomAnnotationRenderer<PdfAnnotationObject>;
-    /** Custom annotation renderers from registry/props */
     annotationRenderers?: BoxedAnnotationRenderer[];
 }
 declare const Annotations: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationsProps, {}, "">;

package/dist/svelte/components/AppearanceImage.svelte.d.ts

@@ -0,0 +1,8 @@
+import { AnnotationAppearanceImage } from '@embedpdf/models';
+interface Props {
+    appearance: AnnotationAppearanceImage<Blob>;
+    style?: string;
+}
+declare const AppearanceImage: import('svelte', { with: { "resolution-mode": "import" } }).Component<Props, {}, "">;
+type AppearanceImage = ReturnType<typeof AppearanceImage>;
+export default AppearanceImage;

package/dist/svelte/components/annotations/Caret.svelte.d.ts

@@ -0,0 +1,13 @@
+import { Rect } from '@embedpdf/models';
+interface CaretProps {
+    isSelected: boolean;
+    strokeColor?: string;
+    opacity?: number;
+    rect: Rect;
+    scale: number;
+    onClick?: (e: PointerEvent) => void;
+    appearanceActive?: boolean;
+}
+declare const Caret: import('svelte', { with: { "resolution-mode": "import" } }).Component<CaretProps, {}, "">;
+type Caret = ReturnType<typeof Caret>;
+export default Caret;

package/dist/svelte/components/annotations/Circle.svelte.d.ts

@@ -1,25 +1,16 @@
 import { PdfAnnotationBorderStyle, Rect } from '@embedpdf/models';
 interface CircleProps {
-    /** Whether the annotation is selected */
     isSelected: boolean;
-    /** Fill colour – defaults to PDFium’s black if omitted */
     color?: string;
-    /** Stroke colour – defaults to same as fill when omitted */
     strokeColor?: string;
-    /** 0 – 1 */
     opacity?: number;
-    /** Stroke width in PDF units */
     strokeWidth: number;
-    /** Stroke type – defaults to solid when omitted */
     strokeStyle?: PdfAnnotationBorderStyle;
-    /** Stroke dash array – defaults to undefined when omitted */
     strokeDashArray?: number[];
-    /** Bounding box of the annotation */
     rect: Rect;
-    /** Current page zoom factor */
     scale: number;
-    /** Pointer/touch handler (used for selection) */
-    onClick?: (e: PointerEvent | TouchEvent) => void;
+    onClick?: (e: PointerEvent) => void;
+    appearanceActive?: boolean;
 }
 declare const Circle: import('svelte', { with: { "resolution-mode": "import" } }).Component<CircleProps, {}, "">;
 type Circle = ReturnType<typeof Circle>;

package/dist/svelte/components/annotations/FreeText.svelte.d.ts

@@ -7,8 +7,9 @@ interface FreeTextProps {
     annotation: TrackedAnnotation<PdfFreeTextAnnoObject>;
     pageIndex: number;
     scale: number;
-    onClick?: (e: MouseEvent | TouchEvent) => void;
+    onClick?: (e: MouseEvent) => void;
     onDoubleClick?: (e: MouseEvent) => void;
+    appearanceActive?: boolean;
 }
 declare const FreeText: import('svelte', { with: { "resolution-mode": "import" } }).Component<FreeTextProps, {}, "">;
 type FreeText = ReturnType<typeof FreeText>;

package/dist/svelte/components/annotations/Ink.svelte.d.ts

@@ -1,14 +1,14 @@
 import { PdfInkListObject, Rect } from '@embedpdf/models';
 interface InkProps {
     isSelected: boolean;
-    /** Stroke color */
     strokeColor?: string;
     opacity?: number;
     strokeWidth: number;
     inkList: PdfInkListObject[];
     rect: Rect;
     scale: number;
-    onClick?: (e: MouseEvent | TouchEvent) => void;
+    onClick?: (e: MouseEvent) => void;
+    appearanceActive?: boolean;
 }
 declare const Ink: import('svelte', { with: { "resolution-mode": "import" } }).Component<InkProps, {}, "">;
 type Ink = ReturnType<typeof Ink>;

package/dist/svelte/components/annotations/Line.svelte.d.ts

@@ -10,8 +10,9 @@ interface LineProps {
     linePoints: LinePoints;
     lineEndings?: LineEndings;
     scale: number;
-    onClick?: (e: MouseEvent | TouchEvent) => void;
+    onClick?: (e: MouseEvent) => void;
     isSelected: boolean;
+    appearanceActive?: boolean;
 }
 declare const Line: import('svelte', { with: { "resolution-mode": "import" } }).Component<LineProps, {}, "">;
 type Line = ReturnType<typeof Line>;

package/dist/svelte/components/annotations/Link.svelte.d.ts

@@ -15,7 +15,7 @@ interface LinkProps {
     /** Current page zoom factor */
     scale: number;
     /** Click handler (used for selection) */
-    onClick?: (e: MouseEvent | TouchEvent) => void;
+    onClick?: (e: MouseEvent) => void;
     /** Whether this link has an IRT (In Reply To) reference - disables direct interaction */
     hasIRT?: boolean;
 }

package/dist/svelte/components/annotations/Polygon.svelte.d.ts

@@ -10,9 +10,10 @@ interface PolygonProps {
     strokeDashArray?: number[];
     scale: number;
     isSelected: boolean;
-    onClick?: (e: MouseEvent | TouchEvent) => void;
+    onClick?: (e: MouseEvent) => void;
     currentVertex?: Position;
     handleSize?: number;
+    appearanceActive?: boolean;
 }
 declare const Polygon: import('svelte', { with: { "resolution-mode": "import" } }).Component<PolygonProps, {}, "">;
 type Polygon = ReturnType<typeof Polygon>;

package/dist/svelte/components/annotations/Polyline.svelte.d.ts

@@ -1,4 +1,4 @@
-import { Rect, Position, LineEndings } from '@embedpdf/models';
+import { Rect, Position, LineEndings, PdfAnnotationBorderStyle } from '@embedpdf/models';
 interface PolylineProps {
     rect: Rect;
     vertices: Position[];
@@ -6,11 +6,13 @@ interface PolylineProps {
     strokeColor?: string;
     opacity?: number;
     strokeWidth: number;
+    strokeStyle?: PdfAnnotationBorderStyle;
+    strokeDashArray?: number[];
     scale: number;
     isSelected: boolean;
-    onClick?: (e: MouseEvent | TouchEvent) => void;
-    /** Optional start & end endings */
+    onClick?: (e: MouseEvent) => void;
     lineEndings?: LineEndings;
+    appearanceActive?: boolean;
 }
 declare const Polyline: import('svelte', { with: { "resolution-mode": "import" } }).Component<PolylineProps, {}, "">;
 type Polyline = ReturnType<typeof Polyline>;

package/dist/svelte/components/annotations/Square.svelte.d.ts

@@ -9,7 +9,8 @@ interface SquareProps {
     strokeDashArray?: number[];
     rect: Rect;
     scale: number;
-    onClick?: (e: MouseEvent | TouchEvent) => void;
+    onClick?: (e: MouseEvent) => void;
+    appearanceActive?: boolean;
 }
 declare const Square: import('svelte', { with: { "resolution-mode": "import" } }).Component<SquareProps, {}, "">;
 type Square = ReturnType<typeof Square>;

package/dist/svelte/components/annotations/Stamp.svelte.d.ts

@@ -6,7 +6,7 @@ interface StampProps {
     annotation: TrackedAnnotation<PdfStampAnnoObject>;
     pageIndex: number;
     scale: number;
-    onClick: (e: MouseEvent | TouchEvent) => void;
+    onClick: (e: MouseEvent) => void;
 }
 declare const Stamp: import('svelte', { with: { "resolution-mode": "import" } }).Component<StampProps, {}, "">;
 type Stamp = ReturnType<typeof Stamp>;

package/dist/svelte/components/annotations/Text.svelte.d.ts

@@ -0,0 +1,10 @@
+interface TextProps {
+    isSelected: boolean;
+    color?: string;
+    opacity?: number;
+    onClick?: (e: PointerEvent) => void;
+    appearanceActive?: boolean;
+}
+declare const Text: import('svelte', { with: { "resolution-mode": "import" } }).Component<TextProps, {}, "">;
+type Text = ReturnType<typeof Text>;
+export default Text;

package/dist/svelte/components/annotations/index.d.ts

@@ -7,3 +7,4 @@ export { default as Polygon } from './Polygon.svelte';
 export { default as Polyline } from './Polyline.svelte';
 export { default as Square } from './Square.svelte';
 export { default as Stamp } from './Stamp.svelte';
+export { default as Text } from './Text.svelte';

package/dist/svelte/components/built-in-renderers.d.ts

@@ -0,0 +1,2 @@
+import { BoxedAnnotationRenderer } from '../context';
+export declare const builtInRenderers: BoxedAnnotationRenderer[];

package/dist/svelte/components/renderers/CaretRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfCaretAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const CaretRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfCaretAnnoObject>, {}, "">;
+type CaretRenderer = ReturnType<typeof CaretRenderer>;
+export default CaretRenderer;

package/dist/svelte/components/renderers/CircleRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfCircleAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const CircleRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfCircleAnnoObject>, {}, "">;
+type CircleRenderer = ReturnType<typeof CircleRenderer>;
+export default CircleRenderer;

package/dist/svelte/components/renderers/FreeTextRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfFreeTextAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const FreeTextRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfFreeTextAnnoObject>, {}, "">;
+type FreeTextRenderer = ReturnType<typeof FreeTextRenderer>;
+export default FreeTextRenderer;

package/dist/svelte/components/renderers/HighlightRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfHighlightAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const HighlightRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfHighlightAnnoObject>, {}, "">;
+type HighlightRenderer = ReturnType<typeof HighlightRenderer>;
+export default HighlightRenderer;

package/dist/svelte/components/renderers/InkRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfInkAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const InkRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfInkAnnoObject>, {}, "">;
+type InkRenderer = ReturnType<typeof InkRenderer>;
+export default InkRenderer;

package/dist/svelte/components/renderers/LineRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfLineAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const LineRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfLineAnnoObject>, {}, "">;
+type LineRenderer = ReturnType<typeof LineRenderer>;
+export default LineRenderer;

package/dist/svelte/components/renderers/LinkRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfLinkAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const LinkRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfLinkAnnoObject>, {}, "">;
+type LinkRenderer = ReturnType<typeof LinkRenderer>;
+export default LinkRenderer;

package/dist/svelte/components/renderers/PolygonRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfPolygonAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const PolygonRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfPolygonAnnoObject>, {}, "">;
+type PolygonRenderer = ReturnType<typeof PolygonRenderer>;
+export default PolygonRenderer;

package/dist/svelte/components/renderers/PolylineRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfPolylineAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const PolylineRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfPolylineAnnoObject>, {}, "">;
+type PolylineRenderer = ReturnType<typeof PolylineRenderer>;
+export default PolylineRenderer;

package/dist/svelte/components/renderers/SquareRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfSquareAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const SquareRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfSquareAnnoObject>, {}, "">;
+type SquareRenderer = ReturnType<typeof SquareRenderer>;
+export default SquareRenderer;

package/dist/svelte/components/renderers/SquigglyRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfSquigglyAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const SquigglyRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfSquigglyAnnoObject>, {}, "">;
+type SquigglyRenderer = ReturnType<typeof SquigglyRenderer>;
+export default SquigglyRenderer;

package/dist/svelte/components/renderers/StampRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfStampAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const StampRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfStampAnnoObject>, {}, "">;
+type StampRenderer = ReturnType<typeof StampRenderer>;
+export default StampRenderer;

package/dist/svelte/components/renderers/StrikeoutRenderer.svelte.d.ts

@@ -0,0 +1,5 @@
+import { PdfStrikeOutAnnoObject } from '@embedpdf/models';
+import { AnnotationRendererProps } from '../../context/types';
+declare const StrikeoutRenderer: import('svelte', { with: { "resolution-mode": "import" } }).Component<AnnotationRendererProps<PdfStrikeOutAnnoObject>, {}, "">;
+type StrikeoutRenderer = ReturnType<typeof StrikeoutRenderer>;
+export default StrikeoutRenderer;